CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-springframework--spring-core

Spring Framework Core - IoC Container and Dependency Injection

—

Pending
Overview
Eval results
Files

utilities.mddocs/

Utilities and Bundled Libraries

Spring Core includes an extensive collection of utility classes and bundled third-party libraries that provide essential functionality for common programming tasks. These utilities handle everything from string manipulation and reflection to bytecode generation and proxy creation.

String Utilities

Spring's StringUtils provides comprehensive string manipulation capabilities that are null-safe and performance-optimized.

StringUtils Class

public abstract class StringUtils {
    // Null and empty checks
    public static boolean isEmpty(Object str);
    public static boolean hasLength(String str);
    public static boolean hasText(String str);
    public static boolean containsWhitespace(String str);
    
    // Trimming operations
    public static String trimWhitespace(String str);
    public static String trimAllWhitespace(String str);
    public static String trimLeadingWhitespace(String str);
    public static String trimTrailingWhitespace(String str);
    public static String trimLeadingCharacter(String str, char leadingCharacter);
    public static String trimTrailingCharacter(String str, char trailingCharacter);
    
    // Case operations
    public static String capitalize(String str);
    public static String uncapitalize(String str);
    
    // String parsing and tokenization
    public static String[] split(String toSplit, String delimiter);
    public static String[] tokenizeToStringArray(String str, String delimiters);
    public static String[] tokenizeToStringArray(String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens);
    public static String[] delimitedListToStringArray(String str, String delimiter);
    public static String[] delimitedListToStringArray(String str, String delimiter, String charsToDelete);
    public static String[] commaDelimitedListToStringArray(String str);
    
    // Collection conversions
    public static String collectionToDelimitedString(Collection<?> coll, String delim);
    public static String collectionToDelimitedString(Collection<?> coll, String delim, String prefix, String suffix);
    public static String collectionToCommaDelimitedString(Collection<?> coll);
    public static String arrayToDelimitedString(Object[] arr, String delim);
    public static String arrayToCommaDelimitedString(Object[] arr);
    
    // Path operations
    public static String cleanPath(String path);
    public static boolean pathEquals(String path1, String path2);
    public static String applyRelativePath(String path, String relativePath);
    public static String getFilename(String path);
    public static String getFilenameExtension(String path);
    public static String stripFilenameExtension(String path);
    
    // Pattern matching
    public static boolean matchesCharacter(String str, char singleCharacter);
    public static boolean startsWithIgnoreCase(String str, String prefix);
    public static boolean endsWithIgnoreCase(String str, String suffix);
    public static boolean substringMatch(CharSequence str, int index, CharSequence substring);
    public static int countOccurrencesOf(String str, String sub);
    
    // String replacement
    public static String replace(String inString, String oldPattern, String newPattern);
    public static String delete(String inString, String pattern);
    public static String deleteAny(String inString, String charsToDelete);
    
    // Locale and language
    public static Locale parseLocale(String localeValue);
    public static Locale parseLocaleString(String localeString);
    public static String toLanguageTag(Locale locale);
    
    // Quote handling
    public static String quote(String str);
    public static Object quoteIfString(Object obj);
    public static String unquote(String str);
}

Usage Examples

// Null-safe string checks
String input = "  Hello World  ";
boolean hasContent = StringUtils.hasText(input); // true
boolean hasLength = StringUtils.hasLength(""); // false
boolean isEmpty = StringUtils.isEmpty(null); // true

// Trimming operations
String trimmed = StringUtils.trimWhitespace(input); // "Hello World"
String noWhitespace = StringUtils.trimAllWhitespace(input); // "HelloWorld"

// Case operations
String capitalized = StringUtils.capitalize("hello"); // "Hello"
String uncapitalized = StringUtils.uncapitalize("Hello"); // "hello"

// String tokenization
String csv = "apple,banana,cherry";
String[] fruits = StringUtils.commaDelimitedListToStringArray(csv);
// Result: ["apple", "banana", "cherry"]

String data = "a;b;c";
String[] tokens = StringUtils.tokenizeToStringArray(data, ";", true, true);

// Collection to string conversion
List<String> items = Arrays.asList("one", "two", "three");
String delimited = StringUtils.collectionToDelimitedString(items, " | ");
// Result: "one | two | three"

String commaList = StringUtils.collectionToCommaDelimitedString(items);
// Result: "one,two,three"

// Path operations
String path = "/user/../admin/./files/document.pdf";
String cleanPath = StringUtils.cleanPath(path); // "/admin/files/document.pdf"
String filename = StringUtils.getFilename(cleanPath); // "document.pdf"
String extension = StringUtils.getFilenameExtension(filename); // "pdf"

// Pattern matching and replacement
String text = "Hello World Hello";
int count = StringUtils.countOccurrencesOf(text, "Hello"); // 2
String replaced = StringUtils.replace(text, "Hello", "Hi"); // "Hi World Hi"
String deleted = StringUtils.delete(text, "Hello"); // " World "

// Locale parsing
Locale locale = StringUtils.parseLocale("en_US"); // Locale.US
String languageTag = StringUtils.toLanguageTag(Locale.FRANCE); // "fr-FR"

Collection Utilities

MultiValueMap Interface and Implementation

public interface MultiValueMap<K, V> extends Map<K, List<V>> {
    V getFirst(K key);
    void add(K key, V value);
    void addAll(K key, List<? extends V> values);
    void addAll(MultiValueMap<K, V> values);
    void set(K key, V value);
    void setAll(Map<K, V> values);
    Map<K, V> toSingleValueMap();
}

public class LinkedMultiValueMap<K, V> implements MultiValueMap<K, V>, Serializable, Cloneable {
    public LinkedMultiValueMap();
    public LinkedMultiValueMap(int initialCapacity);
    public LinkedMultiValueMap(Map<K, List<V>> otherMap);
    
    @Override
    public V getFirst(K key);
    @Override
    public void add(K key, V value);
    @Override
    public void addAll(K key, List<? extends V> values);
    @Override
    public void addAll(MultiValueMap<K, V> values);
    @Override
    public void set(K key, V value);
    @Override
    public void setAll(Map<K, V> values);
    @Override
    public Map<K, V> toSingleValueMap();
    
    @Override
    public LinkedMultiValueMap<K, V> clone();
}

ConcurrentReferenceHashMap

public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V> {
    public enum ReferenceType {
        SOFT, WEAK
    }
    
    public ConcurrentReferenceHashMap();
    public ConcurrentReferenceHashMap(int initialCapacity);
    public ConcurrentReferenceHashMap(int initialCapacity, float loadFactor);
    public ConcurrentReferenceHashMap(int initialCapacity, float loadFactor, int concurrencyLevel);
    public ConcurrentReferenceHashMap(int initialCapacity, float loadFactor, int concurrencyLevel, ReferenceType referenceType);
    
    public int size();
    public boolean isEmpty();
    public V get(Object key);
    public boolean containsKey(Object key);
    public V put(K key, V value);
    public V putIfAbsent(K key, V value);
    public V remove(Object key);
    public boolean remove(Object key, Object value);
    public V replace(K key, V value);
    public boolean replace(K key, V oldValue, V newValue);
    public void clear();
    public void purgeUnreferencedEntries();
}

Usage Examples

// MultiValueMap usage
MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
headers.add("Accept", "application/json");
headers.add("Accept", "application/xml");
headers.add("Content-Type", "application/json");

String firstAccept = headers.getFirst("Accept"); // "application/json"
List<String> allAccepts = headers.get("Accept"); // ["application/json", "application/xml"]

// Convert to single value map
Map<String, String> singleValueMap = headers.toSingleValueMap();
// Result: {"Accept": "application/json", "Content-Type": "application/json"}

// Batch operations
Map<String, String> additionalHeaders = Map.of(
    "Authorization", "Bearer token",
    "User-Agent", "MyApp/1.0"
);
headers.setAll(additionalHeaders);

// ConcurrentReferenceHashMap for memory-sensitive caching
ConcurrentReferenceHashMap<String, Object> cache = new ConcurrentReferenceHashMap<>(
    16, 0.75f, 16, ConcurrentReferenceHashMap.ReferenceType.SOFT);

// Store cached objects that can be garbage collected under memory pressure
cache.put("user:123", loadUser(123));
cache.put("config:app", loadConfiguration());

// Objects may be automatically removed by GC
Object user = cache.get("user:123"); // May return null if GC'd
if (user == null) {
    user = loadUser(123);
    cache.put("user:123", user);
}

// Manually clean up unreferenced entries
cache.purgeUnreferencedEntries();

Reflection Utilities

ReflectionUtils Class

public abstract class ReflectionUtils {
    // Field operations
    public static Field findField(Class<?> clazz, String name);
    public static Field findField(Class<?> clazz, String name, Class<?> type);
    public static void setField(Field field, Object target, Object value);
    public static Object getField(Field field, Object target);
    public static void makeAccessible(Field field);
    public static boolean isPublicStaticFinal(Field field);
    
    // Method operations  
    public static Method findMethod(Class<?> clazz, String name);
    public static Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes);
    public static Object invokeMethod(Method method, Object target);
    public static Object invokeMethod(Method method, Object target, Object... args);
    public static boolean isEqualsMethod(Method method);
    public static boolean isHashCodeMethod(Method method);
    public static boolean isToStringMethod(Method method);
    public static boolean isObjectMethod(Method method);
    public static boolean isCglibRenamedMethod(Method method);
    public static void makeAccessible(Method method);
    
    // Constructor operations
    public static Constructor<T> accessibleConstructor(Class<T> clazz, Class<?>... parameterTypes) throws NoSuchMethodException;
    public static void makeAccessible(Constructor<?> ctor);
    
    // Callback-based iteration
    public static void doWithLocalFields(Class<?> clazz, FieldCallback fc);
    public static void doWithFields(Class<?> clazz, FieldCallback fc);
    public static void doWithFields(Class<?> clazz, FieldCallback fc, FieldFilter ff);
    public static void doWithLocalMethods(Class<?> clazz, MethodCallback mc);
    public static void doWithMethods(Class<?> clazz, MethodCallback mc);
    public static void doWithMethods(Class<?> clazz, MethodCallback mc, MethodFilter mf);
    
    // Method filtering
    public static Method[] getAllDeclaredMethods(Class<?> leafClass);
    public static Method[] getUniqueDeclaredMethods(Class<?> leafClass);
    public static Method[] getUniqueDeclaredMethods(Class<?> leafClass, MethodFilter mf);
    
    // Utility filters
    public static final MethodFilter USER_DECLARED_METHODS;
    public static final MethodFilter COPYABLE_FIELDS;
}

@FunctionalInterface
public interface FieldCallback {
    void doWith(Field field) throws IllegalArgumentException, IllegalAccessException;
}

@FunctionalInterface
public interface MethodCallback {
    void doWith(Method method) throws IllegalArgumentException, IllegalAccessException;
}

@FunctionalInterface
public interface FieldFilter {
    boolean matches(Field field);
}

@FunctionalInterface
public interface MethodFilter {
    boolean matches(Method method);
}

Usage Examples

// Field operations
public class User {
    private String name;
    private int age;
    private final String id = "USER_001";
}

User user = new User();
Class<?> userClass = User.class;

// Find and set field values
Field nameField = ReflectionUtils.findField(userClass, "name");
ReflectionUtils.makeAccessible(nameField);
ReflectionUtils.setField(nameField, user, "John Doe");

Field ageField = ReflectionUtils.findField(userClass, "age");
ReflectionUtils.makeAccessible(ageField);
ReflectionUtils.setField(ageField, user, 30);

// Get field values
String name = (String) ReflectionUtils.getField(nameField, user); // "John Doe"
Integer age = (Integer) ReflectionUtils.getField(ageField, user); // 30

// Method operations
Method toStringMethod = ReflectionUtils.findMethod(userClass, "toString");
String userString = (String) ReflectionUtils.invokeMethod(toStringMethod, user);

// Check method types
boolean isToString = ReflectionUtils.isToStringMethod(toStringMethod); // true
boolean isEquals = ReflectionUtils.isEqualsMethod(toStringMethod); // false

// Iterate over all fields
ReflectionUtils.doWithFields(userClass, field -> {
    System.out.println("Field: " + field.getName() + " Type: " + field.getType());
    if (!ReflectionUtils.isPublicStaticFinal(field)) {
        ReflectionUtils.makeAccessible(field);
        Object value = ReflectionUtils.getField(field, user);
        System.out.println("  Value: " + value);
    }
});

// Iterate over methods with filtering
ReflectionUtils.doWithMethods(userClass, method -> {
    System.out.println("User-declared method: " + method.getName());
}, ReflectionUtils.USER_DECLARED_METHODS);

// Find specific method patterns
ReflectionUtils.doWithMethods(userClass, method -> {
    if (method.getName().startsWith("get") || method.getName().startsWith("set")) {
        System.out.println("Getter/Setter: " + method.getName());
    }
});

// Constructor operations
Constructor<User> constructor = ReflectionUtils.accessibleConstructor(User.class);
User newUser = constructor.newInstance();

Class Utilities

ClassUtils Class

public abstract class ClassUtils {
    // Class loading
    public static Class<?> forName(String name, ClassLoader classLoader) throws ClassNotFoundException, LinkageError;
    public static ClassLoader getDefaultClassLoader();
    public static ClassLoader overrideThreadContextClassLoader(ClassLoader classLoaderToUse);
    public static boolean isPresent(String className, ClassLoader classLoader);
    
    // Class inspection
    public static boolean isVisible(Class<?> clazz, ClassLoader classLoader);
    public static boolean isCacheSafe(Class<?> clazz, ClassLoader classLoader);
    public static Class<?> getUserClass(Object instance);
    public static Class<?> getUserClass(Class<?> clazz);
    
    // Interface operations
    public static Class<?>[] getAllInterfaces(Object instance);
    public static Class<?>[] getAllInterfacesForClass(Class<?> clazz);
    public static Class<?>[] getAllInterfacesForClass(Class<?> clazz, ClassLoader classLoader);
    public static Set<Class<?>> getAllInterfacesAsSet(Object instance);
    public static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz);
    public static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz, ClassLoader classLoader);
    
    // Package and name operations
    public static String getShortName(String className);
    public static String getShortName(Class<?> clazz);
    public static String getShortNameAsProperty(Class<?> clazz);
    public static String getClassFileName(Class<?> clazz);
    public static String getPackageName(Class<?> clazz);
    public static String getPackageName(String fqClassName);
    public static String getQualifiedName(Class<?> clazz);
    public static String getQualifiedMethodName(Method method);
    public static String getQualifiedMethodName(Method method, Class<?> clazz);
    
    // Type checking
    public static boolean matchesTypeName(Class<?> clazz, String typeName);
    public static boolean hasConstructor(Class<?> clazz, Class<?>... paramTypes);
    public static Constructor<T> getConstructorIfAvailable(Class<T> clazz, Class<?>... paramTypes);
    public static boolean hasMethod(Class<?> clazz, String methodName, Class<?>... paramTypes);
    public static Method getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes);
    public static Method getMethodIfAvailable(Class<?> clazz, String methodName, Class<?>... paramTypes);
    public static int getMethodCountForName(Class<?> clazz, String methodName);
    public static boolean hasAtLeastOneMethodWithName(Class<?> clazz, String methodName);
    
    // Primitive and wrapper operations
    public static boolean isPrimitiveWrapper(Class<?> clazz);
    public static boolean isPrimitiveOrWrapper(Class<?> clazz);
    public static boolean isPrimitiveArray(Class<?> clazz);
    public static boolean isPrimitiveWrapperArray(Class<?> clazz);
    public static Class<?> resolvePrimitiveIfNecessary(Class<?> clazz);
    public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType);
    public static boolean isAssignableValue(Class<?> type, Object value);
    
    // Array operations
    public static String addResourcePathToPackagePath(Class<?> clazz, String resourceName);
    public static String classPackageAsResourcePath(Class<?> clazz);
    public static String classNamesToString(Class<?>... classes);
    public static String classNamesToString(Collection<Class<?>> classes);
    public static Class<?>[] toClassArray(Collection<Class<?>> collection);
}

Usage Examples

// Class loading and presence checking
ClassLoader classLoader = ClassUtils.getDefaultClassLoader();
boolean hasJackson = ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", classLoader);

if (hasJackson) {
    Class<?> objectMapperClass = ClassUtils.forName("com.fasterxml.jackson.databind.ObjectMapper", classLoader);
}

// Class name operations
Class<?> userClass = User.class;
String shortName = ClassUtils.getShortName(userClass); // "User"
String packageName = ClassUtils.getPackageName(userClass); // "com.example"
String qualifiedName = ClassUtils.getQualifiedName(userClass); // "com.example.User"
String propertyName = ClassUtils.getShortNameAsProperty(userClass); // "user"

// Interface operations
Set<Class<?>> allInterfaces = ClassUtils.getAllInterfacesForClassAsSet(ArrayList.class);
// Includes: List, Collection, Iterable, RandomAccess, Cloneable, Serializable

// Method operations
boolean hasToString = ClassUtils.hasMethod(userClass, "toString");
Method toStringMethod = ClassUtils.getMethodIfAvailable(userClass, "toString");
int toStringCount = ClassUtils.getMethodCountForName(userClass, "toString");

// Constructor operations
boolean hasDefaultConstructor = ClassUtils.hasConstructor(userClass);
Constructor<User> constructor = ClassUtils.getConstructorIfAvailable(User.class, String.class);

// Type checking
boolean isPrimitive = ClassUtils.isPrimitiveOrWrapper(Integer.class); // true
boolean isAssignable = ClassUtils.isAssignable(Number.class, Integer.class); // true
boolean canAssignValue = ClassUtils.isAssignableValue(String.class, "hello"); // true

// Get user class (unwrap proxies)
Object proxyObject = createProxyFor(new UserService());
Class<?> actualClass = ClassUtils.getUserClass(proxyObject); // UserService.class

Path Matching

AntPathMatcher Class

public class AntPathMatcher implements PathMatcher {
    public static final String DEFAULT_PATH_SEPARATOR = "/";
    
    public AntPathMatcher();
    public AntPathMatcher(String pathSeparator);
    
    public void setPathSeparator(String pathSeparator);
    public void setCaseSensitive(boolean caseSensitive);
    public void setTrimTokens(boolean trimTokens);
    public void setCachePatterns(boolean cachePatterns);
    
    @Override
    public boolean isPattern(String path);
    @Override
    public boolean match(String pattern, String path);
    @Override
    public boolean matchStart(String pattern, String path);
    @Override
    public String extractPathWithinPattern(String pattern, String path);
    @Override
    public Map<String, String> extractUriTemplateVariables(String pattern, String path);
    @Override
    public Comparator<String> getPatternComparator(String path);
    @Override
    public String combine(String pattern1, String pattern2);
}

Usage Examples

// Create path matcher
AntPathMatcher pathMatcher = new AntPathMatcher();
pathMatcher.setCaseSensitive(false);
pathMatcher.setTrimTokens(true);

// Pattern matching
boolean matches1 = pathMatcher.match("*.txt", "readme.txt"); // true
boolean matches2 = pathMatcher.match("/users/**", "/users/123/profile"); // true
boolean matches3 = pathMatcher.match("/api/{version}/users", "/api/v1/users"); // true

// Pattern checking
boolean isPattern = pathMatcher.isPattern("/users/{id}"); // true
boolean isLiteral = pathMatcher.isPattern("/users/123"); // false

// Extract variables
String pattern = "/users/{userId}/orders/{orderId}";
String path = "/users/123/orders/456";
Map<String, String> variables = pathMatcher.extractUriTemplateVariables(pattern, path);
// Result: {userId=123, orderId=456}

// Extract path within pattern
String extracted = pathMatcher.extractPathWithinPattern("/static/**", "/static/css/style.css");
// Result: "css/style.css"

// Pattern combination
String combined = pathMatcher.combine("/api/**", "users/{id}"); // "/api/**/users/{id}"

// Comparator for pattern ordering
List<String> patterns = Arrays.asList("/users/*", "/users/**", "/users/{id}");
patterns.sort(pathMatcher.getPatternComparator("/users/123"));
// Most specific patterns first: ["/users/{id}", "/users/*", "/users/**"]

MIME Type Support

MimeType Class

public class MimeType implements Comparable<MimeType>, Serializable {
    public static final String WILDCARD_TYPE = "*";
    
    public MimeType(String type);
    public MimeType(String type, String subtype);
    public MimeType(String type, String subtype, Charset charset);
    public MimeType(String type, String subtype, Map<String, String> parameters);
    public MimeType(MimeType other, Charset charset);
    public MimeType(MimeType other, Map<String, String> parameters);
    
    protected MimeType(MimeType other);
    
    public String getType();
    public String getSubtype();
    public Charset getCharset();
    public Map<String, String> getParameters();
    public String getParameter(String name);
    
    public boolean isWildcardType();
    public boolean isWildcardSubtype();
    public boolean isConcrete();
    
    public boolean includes(MimeType other);
    public boolean isCompatibleWith(MimeType other);
    public boolean equalsTypeAndSubtype(MimeType other);
    public boolean isPresentIn(Collection<? extends MimeType> mimeTypes);
    
    @Override
    public int compareTo(MimeType other);
    
    public static MimeType valueOf(String value);
}

MimeTypeUtils Class

public abstract class MimeTypeUtils {
    public static final MimeType ALL;
    public static final String ALL_VALUE = "*/*";
    public static final MimeType APPLICATION_JSON;
    public static final String APPLICATION_JSON_VALUE = "application/json";
    public static final MimeType APPLICATION_OCTET_STREAM;
    public static final String APPLICATION_OCTET_STREAM_VALUE = "application/octet-stream";
    public static final MimeType APPLICATION_XML;
    public static final String APPLICATION_XML_VALUE = "application/xml";
    public static final MimeType IMAGE_GIF;
    public static final String IMAGE_GIF_VALUE = "image/gif";
    public static final MimeType IMAGE_JPEG;
    public static final String IMAGE_JPEG_VALUE = "image/jpeg";
    public static final MimeType IMAGE_PNG;
    public static final String IMAGE_PNG_VALUE = "image/png";
    public static final MimeType TEXT_HTML;
    public static final String TEXT_HTML_VALUE = "text/html";
    public static final MimeType TEXT_PLAIN;
    public static final String TEXT_PLAIN_VALUE = "text/plain";
    public static final MimeType TEXT_XML;
    public static final String TEXT_XML_VALUE = "text/xml";
    
    public static MimeType parseMimeType(String mimeType);
    public static List<MimeType> parseMimeTypes(String mimeTypes);
    public static List<MimeType> parseMimeTypes(List<String> mimeTypes);
    public static String toString(Collection<? extends MimeType> mimeTypes);
    
    public static void sortBySpecificity(List<MimeType> mimeTypes);
}

Usage Examples

// Create MIME types
MimeType jsonType = new MimeType("application", "json");
MimeType xmlType = new MimeType("application", "xml", StandardCharsets.UTF_8);
MimeType htmlType = MimeType.valueOf("text/html;charset=UTF-8");

// Use predefined constants
MimeType appJson = MimeTypeUtils.APPLICATION_JSON;
MimeType textPlain = MimeTypeUtils.TEXT_PLAIN;

// Parse MIME types
MimeType parsed = MimeTypeUtils.parseMimeType("application/json;charset=UTF-8");
List<MimeType> accepts = MimeTypeUtils.parseMimeTypes("text/html,application/xml;q=0.9,*/*;q=0.8");

// Type checking
boolean isJson = parsed.equalsTypeAndSubtype(MimeTypeUtils.APPLICATION_JSON); // true
boolean isWildcard = MimeTypeUtils.ALL.isWildcardType(); // true
boolean isConcrete = jsonType.isConcrete(); // true

// Compatibility checking
boolean includes = MimeTypeUtils.ALL.includes(jsonType); // true
boolean compatible = jsonType.isCompatibleWith(MimeTypeUtils.APPLICATION_JSON); // true

// Parameter access
Charset charset = htmlType.getCharset(); // UTF-8
String boundaryParam = parsed.getParameter("boundary");

// Sorting by specificity
List<MimeType> mimeTypes = Arrays.asList(
    MimeTypeUtils.ALL,
    MimeTypeUtils.APPLICATION_JSON,
    MimeType.valueOf("application/*")
);
MimeTypeUtils.sortBySpecificity(mimeTypes);
// Result: [APPLICATION_JSON, application/*, */*] (most specific first)

// Collection operations
Collection<MimeType> supportedTypes = Arrays.asList(
    MimeTypeUtils.APPLICATION_JSON,
    MimeTypeUtils.APPLICATION_XML,
    MimeTypeUtils.TEXT_HTML
);
boolean isSupported = jsonType.isPresentIn(supportedTypes); // true

Bundled Third-Party Libraries

Spring Core includes several repackaged third-party libraries for internal use.

ASM Bytecode Manipulation (org.springframework.asm)

// Available packages:
// org.springframework.asm - Core ASM functionality
// org.springframework.asm.commons - Common ASM utilities  
// org.springframework.asm.signature - Signature parsing
// org.springframework.asm.tree - Tree API for bytecode manipulation
// org.springframework.asm.util - Debugging and analysis utilities

// Note: These are repackaged for Spring's internal use
// For application use, depend on ASM directly

CGLib Proxy Creation (org.springframework.cglib)

// Available packages:
// org.springframework.cglib.core - Core CGLib functionality
// org.springframework.cglib.proxy - Proxy creation and enhancement
// org.springframework.cglib.beans - Bean utilities and property access
// org.springframework.cglib.reflect - Fast reflection utilities
// org.springframework.cglib.transform - Bytecode transformation

// Note: These are repackaged for Spring's internal use
// For application use, depend on CGLib directly

JavaPoet Code Generation (org.springframework.javapoet)

// Available for AOT code generation:
// org.springframework.javapoet.ClassName
// org.springframework.javapoet.CodeBlock  
// org.springframework.javapoet.FieldSpec
// org.springframework.javapoet.JavaFile
// org.springframework.javapoet.MethodSpec
// org.springframework.javapoet.TypeSpec

// Note: This is bundled for Spring's AOT compilation support

Objenesis Object Instantiation (org.springframework.objenesis)

// Available classes:
// org.springframework.objenesis.SpringObjenesis - Spring-configured Objenesis
// org.springframework.objenesis.ObjenesisException - Exception handling

// Note: This is bundled for Spring's proxy creation needs

Usage Notes

  • These bundled libraries are repackaged under org.springframework.* namespaces
  • They are intended for Spring Framework's internal use
  • Applications should depend on the original libraries directly if needed
  • Spring uses these for proxy creation, bytecode generation, and AOT compilation
  • The bundled versions are tested and guaranteed to work with the specific Spring version

This comprehensive utility library provides essential tools that power Spring's internal operations while also offering valuable utilities for application developers to handle common programming tasks efficiently and safely.

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework--spring-core

docs

annotation-processing.md

aot-optimization.md

core-infrastructure.md

environment-config.md

index.md

resource-management.md

task-execution.md

type-conversion.md

utilities.md

tile.json