Không cần viết code từ đầu nữa! Tổng hợp đầy đủ các lớp tiện ích tích hợp sẵn tiện lợi trong Spring

Giới thiệu

Xin chào! Trong quá trình phát triển hàng ngày, tôi đã phát hiện ra một "trợ thủ đắc lực" được tích hợp sẵn trong Spring Framework. Hôm nay, tôi muốn chia sẻ tính năng tuyệt vời này với các bạn.

Bạn có thường xuyên viết lại cùng một đoạn code trong công việc phát triển hàng ngày không? Khi mới vào công ty, tôi đã tự tạo các lớp tiện ích để xử lý chuỗi và tính toán ngày tháng. Một ngày nọ, đồng nghiệp senior đã nói với tôi: "Spring đã cung cấp sẵn những thứ đó rồi!" và tôi đã rất ngạc nhiên!

Thực tế, Spring Framework có tích hợp sẵn nhiều lớp tiện ích mạnh mẽ có thể được sử dụng trong nhiều tình huống khác nhau như thao tác I/O, chuyển đổi Bean, đánh giá điều kiện, v.v. Sử dụng chúng, bạn có thể thực hiện hàng chục dòng xử lý chỉ với một dòng code. Ví dụ, phương thức StringUtils.hasText có thể thay thế hơn 8 dòng code bao gồm kiểm tra null, kiểm tra chuỗi rỗng và kiểm tra ký tự trắng. Đây thực sự là "con dao quân đội Thụy Sĩ" của nhà phát triển!

Trong bài viết này, tôi sẽ giới thiệu 24 lớp tiện ích mạnh mẽ có sẵn trong Spring. Sử dụng chúng sẽ giúp tăng đáng kể hiệu quả phát triển của bạn!

Các trường hợp thực tế Spring: 24 lớp tiện ích tích hợp sẵn

Các lớp tiện ích liên quan đến Bean (gói spring-beans, 4 loại)

Các tiện ích này nằm trong gói spring-beans và cung cấp 4 lớp rất hữu ích.

• BeanUtils
  Các phương thức tiện ích tĩnh cho JavaBeans: Được sử dụng để khởi tạo Bean, kiểm tra kiểu thuộc tính Bean, sao chép thuộc tính Bean, v.v. Dưới đây là ví dụ sử dụng:

  /**1.Sao chép thuộc tính đối tượng*/
  User source = new User(1L, "PackXg") ;
  User target = new User() ;
  BeanUtils.copyProperties(source, target) ; /**2.Khởi tạo đối tượng*/
  User instance = BeanUtils.instantiateClass(User.class) ; /**3.Kiểm tra xem kiểu được chỉ định có phải là kiểu giá trị 'đơn giản' cho thuộc tính Bean và kịch bản ràng buộc dữ liệu hay không*/
  Class<?> type = User.class.getDeclaredField("name").getType() ;
  boolean isSimpleType = BeanUtils.isSimpleValueType(type) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/1.2.8/javadoc-api/org/springframework/beans/BeanUtils.html

• BeanFactoryUtils
  Các phương thức thao tác thuận tiện cho bean factory, đặc biệt là các tính năng mở rộng của giao diện ListableBeanFactory:

  • Trả về số lượng, tên, thể hiện của Bean
  • Đặc điểm quan trọng: Hỗ trợ xử lý cấu trúc phân cấp lồng nhau của bean factory (các phương thức gốc của giao diện ListableBeanFactory không hỗ trợ tính năng này)

  Dưới đây là ví dụ sử dụng:

   ListableBeanFactory beanFactory = ... ; /**1.Trả về một bean duy nhất thuộc kiểu được chỉ định hoặc kiểu con của nó (không tìm kiếm trong các factory cha)*/ CommonDAO dao = BeanFactoryUtils.beanOfType(beanFactory, CommonDAO.class) ; /**2.Lấy tên của tất cả các bean có kiểu chú thích được chỉ định*/ String[] beanNames = BeanFactoryUtils.beanNamesForAnnotationIncludingAncestors(beanFactory, Pack.class) ; /**3.Trả về tất cả các bean thuộc kiểu được chỉ định hoặc kiểu con của nó*/ Map<String, CommonDAO> beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(beanFactory, CommonDAO.class) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/BeanFactoryUtils.html

• BeanFactoryAnnotationUtils
  Các phương thức thuận tiện để tìm kiếm bean dựa trên chú thích cụ thể của Spring (như chú thích @Qualifier của Spring). Dưới đây là ví dụ sử dụng:

  // Trước tiên, định nghĩa các bean như sau
  @Component
  @Qualifier("product")
  public class ProductDAO implements CommonDAO {
  }
  @Component
  @Qualifier("user")
  public class UserDAO implements CommonDAO {
  } ConfigurableListableBeanFactory beanFactory = ... ;
  // Lấy bean có tên "user" bằng cách sử dụng chú thích @Qualifier
  CommonDAO userDAO = BeanFactoryAnnotationUtils.qualifiedBeanOfType(beanFactory, CommonDAO.class, "user") ;
  // Lấy bean có tên "product" bằng cách sử dụng chú thích @Qualifier
  CommonDAO productDAO = BeanFactoryAnnotationUtils.qualifiedBeanOfType(beanFactory, CommonDAO.class, "product") ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/annotation/BeanFactoryAnnotationUtils.html

• BeanDefinitionReaderUtils
  Các phương thức tiện ích cho việc triển khai trình đọc định nghĩa bean, chủ yếu được sử dụng nội bộ. Dưới đây là ví dụ sử dụng:

  BeanDefinitionRegistry registry = ... ;
  // 1.Tạo beanName từ BeanDefinition
  AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder .genericBeanDefinition(UserDAO.class) .getBeanDefinition() ;
  String beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, registry) ; // 2.Đăng ký bean
  BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, beanName) ;
  BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/support/BeanDefinitionReaderUtils.html

Các lớp tiện ích liên quan đến AOP (gói spring-aop, 6 loại)

Các tiện ích này nằm trong gói spring-aop và cung cấp 6 lớp rất hữu ích.

• AopConfigUtils
  Lớp tiện ích để xử lý việc đăng ký trình tạo proxy tự động AOP. Dưới đây là ví dụ sử dụng:

  BeanDefinitionRegistry registry = ... ;
  /**1.Phương thức này tự động đăng ký InfrastructureAdvisorAutoProxyCreator*/
  // Việc đăng ký lớp này được sử dụng cho proxy động
  AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry) ; /**2.Phương thức này tự động đăng ký AnnotationAwareAspectJAutoProxyCreator*/
  // Tương tự, lớp này cũng được sử dụng cho proxy động
  AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry) ;
  // Khi khởi động container Spring Boot, nếu có starter liên quan (như spring-boot-starter-aop),
  // BeanPostProcessor liên quan sẽ được đăng ký thông qua phương thức trên.
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/aop/config/AopConfigUtils.html

• AopProxyUtils
  Các phương thức tiện ích cho factory proxy AOP. Dưới đây là ví dụ sử dụng:

  /**1.Lấy đối tượng mục tiêu singleton (đối tượng gốc) đằng sau lớp proxy được chỉ định*/
  // Nếu đối tượng này là đối tượng proxy được tạo bởi Spring
  UserDAO proxy = ... ;
  // Phương thức này trả về đối tượng gốc đằng sau đối tượng proxy
  Object targetObject = AopProxyUtils.getSingletonTarget(proxy) ; /**2.Trả về các giao diện mà đối tượng proxy hiện tại đang triển khai (ngoại trừ các giao diện được triển khai theo đặc tả của Spring)*/
  Class<?>[] userInterfaces = AopProxyUtils.proxiedUserInterfaces(proxy) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/aop/framework/AopProxyUtils.html

• AutoProxyUtils
  Tiện ích cho các thành phần hỗ trợ proxy tự động, chủ yếu được sử dụng nội bộ trong framework. Dưới đây là ví dụ sử dụng:

  ConfigurableListableBeanFactory beanFactory = ... ; /**1.Lấy lớp mục tiêu gốc tương ứng với bean được chỉ định*/
  Class<?> targetClass = AutoProxyUtils.determineTargetClass(beanFactory, "userDAO") ; /**2.Xác định xem bean được chỉ định có nên được proxy dựa trên lớp mục tiêu của nó (không phải giao diện) hay không*/
  // Tức là xác định xem đó là proxy JDK hay proxy CGLIB
  AutoProxyUtils.shouldProxyTargetClass(beanFactory, "userDAO") ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/aop/framework/autoproxy/AutoProxyUtils.html

• ScopedProxyUtils
  Lớp tiện ích để tạo proxy có phạm vi, thường được sử dụng bởi ScopedProxyBeanDefinitionDecorator và ClassPathBeanDefinitionScanner. Dưới đây là ví dụ sử dụng:

  try (GenericApplicationContext context = new GenericApplicationContext()) { BeanDefinition beanDefinition = BeanDefinitionBuilder .genericBeanDefinition(UserDAO.class) .getBeanDefinition() ; BeanDefinitionHolder definition = new BeanDefinitionHolder(beanDefinition, "userDAO") ; BeanDefinitionHolder scopedProxy = ScopedProxyUtils.createScopedProxy(definition, context, true) ; context.registerBeanDefinition("userDAO", scopedProxy.getBeanDefinition()) ; context.refresh(); UserDAO dao = context.getBean(UserDAO.class) ; System.err.println(dao.getClass()) ;
  }
  

  Khi chạy đoạn code trên, kết quả sẽ là:

  class com.pack.UserDAO$$SpringCGLIB$$0
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/aop/scope/ScopedProxyUtils.html

• AopUtils
  Các phương thức tiện ích để hỗ trợ AOP. Dưới đây là ví dụ sử dụng:

  UserDAO userDAO = ... ; /**1.Lấy lớp mục tiêu gốc tương ứng với bean*/
  AopUtils.getTargetClass(userDAO) ; /**2.Xác định xem đối tượng có phải là đối tượng proxy hay không (bao gồm cả JDK và CGLIB)*/
  AopUtils.isAopProxy(userDAO) ; /**3.Xác định xem Advisor (aspect) được chỉ định có thể áp dụng cho đối tượng Class được chỉ định hay không*/
  Advisor advisor = ... ;
  AopUtils.canApply(advisor, UserDAO.class) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/aop/support/AopUtils.html

• ClassFilters
  Các phương thức tiện ích tĩnh để kết hợp ClassFilter. Bên trong Spring, ClassFilter được sử dụng để xác định xem một lớp có thể được proxy hay không, và lớp tiện ích này kết hợp nhiều ClassFilter để đánh giá (đánh giá nhiều điều kiện). Dưới đây là ví dụ sử dụng:

  ClassFilter f1 = new ClassFilter() { public boolean matches(Class<?> clazz) { return clazz.getPackageName().startsWith("com.pack.aop") ; }
  };
  ClassFilter f2 = new ClassFilter() { public boolean matches(Class<?> clazz) { return clazz.isAssignableFrom(CommonDAO.class) ; }
  };
  ClassFilter[] classFilters = new ClassFilter[] {f1, f2} ;
  /**1.Sử dụng tập hợp 'bộ lọc lớp' (ClassFilter) được chỉ định để lọc các lớp, và một lớp được chọn nếu nó khớp với một (hoặc tất cả) bộ lọc*/
  ClassFilter classFilter = ClassFilters.union(classFilters) ; /**2.Trả về bộ lọc lớp biểu thị phủ định logic của thể hiện bộ lọc được chỉ định (khớp với tất cả các lớp không thỏa mãn điều kiện bộ lọc ban đầu)*/
  classFilter = ClassFilters.negate(f1) ; /**3.Tất cả các ClassFilter được chỉ định phải khớp*/
  classFilter = ClassFilters.intersection(classFilters) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/aop/support/ClassFilters.html

Các lớp tiện ích Spring Core (gói spring-core, 14 loại)

Các tiện ích này nằm trong gói spring-core và cung cấp 14 lớp rất hữu ích.

• ReflectUtils
  Tiện ích này chủ yếu được sử dụng để thực hiện các thao tác liên quan thông qua reflection. Dưới đây là ví dụ sử dụng:

  /**1.Tạo thể hiện*/
  ReflectUtils.newInstance(UserDAO.class) ; /**2.Tìm kiếm đối tượng Method*/
  ReflectUtils.findDeclaredMethod(UserDAO.class, "create", new Class<?>[] {String.class}) ; /**3.Lấy tất cả các phương thức getter tương ứng với java bean*/
  PropertyDescriptor[] getters = ReflectUtils.getBeanGetters(UserDAO.class);
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/cglib/core/ReflectUtils.html

• ResourcePatternUtils
  Lớp tiện ích để xác định xem URL được chỉ định có phải là vị trí tài nguyên có thể tải thông qua ResourcePatternResolver hay không. Dưới đây là ví dụ sử dụng:

  String resourceLocation = "classpath:com/pack.properties";
  boolean isUrl = ResourcePatternUtils.isUrl(resourceLocation) ;
  System.err.println(isUrl) ; resourceLocation = "com/pack.properties";
  isUrl = ResourcePatternUtils.isUrl(resourceLocation) ;
  System.err.println(isUrl) ; resourceLocation = "file:///d:/pack.properties";
  isUrl = ResourcePatternUtils.isUrl(resourceLocation) ;
  System.err.println(isUrl) ; resourceLocation = "http://www.pack.com/pack.properties";
  isUrl = ResourcePatternUtils.isUrl(resourceLocation) ;
  System.err.println(isUrl) ;
  

  Kết quả đầu ra:

  true
  false
  true
  true
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/io/support/ResourcePatternUtils.html

• DigestUtils
  Được sử dụng để tính toán giá trị digest (hash). Dưới đây là ví dụ sử dụng:

  String hex = DigestUtils.md5DigestAsHex("Spring Boot3 200 trường hợp thực tế".getBytes()) ;
  // Đầu ra: e329f65bf350e618cf3a183aba20e362
  System.err.println(hex) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/DigestUtils.html

• LogFormatUtils
  Lớp tiện ích định dạng log, kiểm soát độ dài của log. Dưới đây là ví dụ sử dụng:

  /**1.Đầu ra không giới hạn độ dài*/
  String ret = LogFormatUtils.formatValue(new User(1L, "PackXg"), false) ;
  System.err.println(ret) ; /**2.Đầu ra có giới hạn độ dài*/
  ret = LogFormatUtils.formatValue(new User(1L, "PackXg"), 10, true) ;
  System.err.println(ret) ; /**3.Đầu ra log tùy chỉnh*/
  Log logger = LogFactory.getLog(User.class) ;
  LogFormatUtils.traceDebug(logger, traceEnabled -> "Spring Boot3 200 trường hợp thực tế");
  

  Kết quả đầu ra:

  User [id=1, name=PackXg]
  User [id=1 (truncated)...
  

  ▼ Tài liệu chính thức: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/log/LogFormatUtils.html

• PropertiesLoaderUtils
  Các phương thức tiện ích để tải java.util.Properties, cung cấp xử lý chuẩn cho luồng đầu vào. Dưới đây là ví dụ sử dụng:

  /**1.Tải tài nguyên*/
  Properties properties = PropertiesLoaderUtils.loadAllProperties("pack.properties") ;
  System.err.println(properties) ; /**2.Điền tài nguyên*/
  Properties prop = new Properties() ;
  Resource resource = new ClassPathResource("pack.properties") ;
  PropertiesLoaderUtils.fillProperties(prop, resource) ;
  System.err.println(prop) ;
  

  Kết quả đầu ra:

  {pack.app.version=1.0.0, pack.app.title=xxxooo}
  {pack.app.version=1.0.0, pack.app.title=xxxooo}
  

  ▼ Tài liệu chính thức: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/io/support/PropertiesLoaderUtils.html

• AnnotatedElementUtils
  Các phương thức tiện ích chung để tìm kiếm chú thích, meta-chú thích và chú thích lặp lại trên AnnotatedElement (lớp, phương thức, trường, v.v. - các phần tử có thể chú thích). Dưới đây là ví dụ sử dụng:

  /**1.Tìm kiếm chú thích @Component trên lớp*/
  Set<Component> annotations = AnnotatedElementUtils .findAllMergedAnnotations(UserDAO.class, Component.class) ;
  // Đầu ra: [@org.springframework.stereotype.Component("")]
  System.err.println(annotations) ; /**2.Lấy tất cả thuộc tính của chú thích được chỉ định (@Qualifier)*/
  MultiValueMap<String,Object> attributes = AnnotatedElementUtils .getAllAnnotationAttributes(UserDAO.class, Qualifier.class.getName()) ;
  // Đầu ra: {value=[user]}
  System.err.println(attributes) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/annotation/AnnotatedElementUtils.html

• ClassUtils
  Tập hợp các phương thức tiện ích khác nhau liên quan đến java.lang.Class. Dưới đây là ví dụ sử dụng:

  /**1.Tải lớp*/
  Class<?> clazz = ClassUtils.forName("com.pack.utils.zdomain.User", ClassUtilsTest.class.getClassLoader()) ;
  System.err.println(clazz) ; /**2.Lấy đối tượng Method của phương thức*/
  Method method = ClassUtils.getMethod(clazz, "getId") ;
  System.err.println(method) ; /**3.Lấy tất cả các giao diện mà đối tượng đang triển khai*/
  Class<?>[] interfaces = ClassUtils.getAllInterfaces(new UserDAO()) ;
  System.err.println(Arrays.toString(interfaces)) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/ClassUtils.html

• OrderUtils
  Lớp tiện ích chung để xác định thứ tự thực thi dựa trên khai báo kiểu đối tượng, hỗ trợ chú thích Order của Spring và chú thích Priority của Jakarta EE. Dưới đây là ví dụ sử dụng:

  /**1.Lấy giá trị được đặt bởi chú thích @Order trên lớp*/
  Integer order = OrderUtils.getOrder(UserDAO.class) ;
  System.err.println(order); /**2.Lấy giá trị @Order trên phương thức*/
  order = OrderUtils.getOrder(AppConfig.class.getMethod("userDAO")) ;
  System.err.println(order);
  

  ▼ Tài liệu chính thức: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/annotation/OrderUtils.html

• FileCopyUtils
  Tập hợp các phương thức tiện ích đơn giản để sao chép tệp và luồng. Tất cả các phương thức sao chép sử dụng kích thước khối 4096 byte và tự động đóng tất cả các luồng bị ảnh hưởng sau khi hoàn thành. Dưới đây là ví dụ sử dụng:

  byte[] data = "Spring Boot3 200 trường hợp thực tế".getBytes(StandardCharsets.UTF_8) ;
  /**1.Ghi dữ liệu vào tệp*/
  FileCopyUtils.copy(data, new File("f:\\1.txt")) ; /**2.Ghi dữ liệu vào luồng byte*/
  ByteArrayOutputStream baos = new ByteArrayOutputStream() ;
  FileCopyUtils.copy(data, baos) ; /**3.Đọc nội dung tệp*/
  byte[] array = FileCopyUtils.copyToByteArray(new File("f:\\1.txt")) ;
  System.err.println(new String(array, StandardCharsets.UTF_8)) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/FileCopyUtils.html

• FileSystemUtils
  Tập hợp các phương thức tiện ích để thao tác hệ thống tệp. Dưới đây là ví dụ sử dụng:

  File src = null ;
  File dest = null ;
  /**1.Sao chép tệp đệ quy*/
  FileSystemUtils.copyRecursively(src, dest) ;
  /**2.Xóa tệp được chỉ định—nếu mục tiêu là thư mục, xóa đệ quy tất cả các thư mục và tệp lồng nhau*/
  FileSystemUtils.deleteRecursively(src) ;
  

  ▼ Tài liệu chính thức: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/FileSystemUtils.html

• MimeTypeUtils
  Tập hợp các phương thức tiện ích khác nhau liên quan đến kiểu MIME (kiểu phương tiện). Dưới đây là ví dụ sử dụng:

  /**1.Phân tích chuỗi thành kiểu MimeType*/
  MimeType mimeType = MimeTypeUtils.parseMimeType("application/json") ;
  System.err.println(mimeType) ;
  

  ▼ Tài liệu chính thức: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/MimeTypeUtils.html

• NumberUtils
  Tập hợp các phương thức tiện ích khác nhau liên quan đến chuyển đổi và phân tích số. Dưới đây là ví dụ sử dụng:

  /**1.Phân tích chuỗi thành kiểu được chỉ định*/
  Double number = NumberUtils.parseNumber("20", Double.class) ;
  System.err.println(number) ; /**2.Chuyển đổi từ một kiểu sang kiểu được chỉ định*/
  Number n = 20 ;
  Integer ret = NumberUtils.convertNumberToTargetClass(n, Integer.class) ;
  System.err.println(ret) ;
  

  ▼ Tài liệu chính thức: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/NumberUtils.html

• StreamUtils
  Tập hợp các phương thức tiện ích đơn giản để xử lý luồng (Stream). Các phương thức sao chép của lớp này tương tự như của FileCopyUtils, nhưng khác ở chỗ tất cả các luồng bị ảnh hưởng không tự động đóng (vẫn mở) sau khi hoàn thành. Tất cả các phương thức sao chép sử dụng kích thước khối 8192 byte (8KB) để truyền dữ liệu. Dưới đây là ví dụ sử dụng:

  InputStream in = ... ;
  OutputStream out = ... ;
  /**1.Sao chép từ luồng đầu vào sang luồng đầu ra*/
  StreamUtils.copy(in, out) ; /**2.Sao chép luồng đầu vào thành mảng byte*/
  StreamUtils.copyToByteArray(in) ;
  

  ▼ Tài liệu chính thức:
  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/StreamUtils.html

• StringUtils
  Tập hợp các tiện ích thao tác chuỗi. Dưới đây là ví dụ sử dụng:

  String s = "" ;
  /**1.Xác định xem chuỗi có rỗng hay không*/
  StringUtils.hasLength(s) ; /**2.Xác định xem chuỗi có chứa ký tự trắng hay không; sự hiện diện của ký tự trắng được xác định bởi Character.isWhitespace*/
  StringUtils.containsWhitespace(s) ; /**3.Chuyển đổi bộ sưu tập thành mảng chuỗi*/
  StringUtils.toStringArray(List.of("a", "b", "c")) ;
  

  ▼ Tài liệu chính thức: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/StringUtils.html

Khuyến nghị thêm: Công cụ hiệu quả phát triển liên quan đến API

Các lớp tiện ích tích hợp sẵn của Spring bao gồm các kịch bản thông thường như Bean, AOP, IO, xử lý chuỗi, nhưng không có công cụ trực tiếp cho thiết kế API, gỡ lỗi, mô phỏng, kiểm thử, quản lý tài liệu.

Điểm giá trị của Apidog:

• Nền tảng API tích hợp: Bao gồm đầy đủ thiết kế, gỡ lỗi, mô phỏng, kiểm thử, tài liệu
• Kiểm thử tự động: Giảm thiểu công việc lặp lại thủ công
• Dễ dàng kết hợp với dự án Spring Boot và xác thực nhanh chóng REST API
• Hỗ trợ cộng tác nhóm và nâng cao hiệu quả phát triển và kiểm thử bảo mật

Tóm tắt

• 24 loại lớp tiện ích tích hợp sẵn của Spring = con dao quân đội Thụy Sĩ của nhà phát triển, giúp tránh phải tái phát minh bánh xe.
• Apidogg = bộ tăng tốc dành riêng cho API, bổ sung cho khoảng trống của các lớp tiện ích Spring.
• Kết hợp cả hai sẽ cải thiện đáng kể hiệu quả phát triển, hiệu quả kiểm thử và cộng tác nhóm!

Tôi hy vọng các lớp tiện ích của Spring được giới thiệu trong bài viết này sẽ giúp cải thiện hiệu quả phát triển của bạn. Nếu bạn có bất kỳ câu hỏi hoặc ý kiến nào, vui lòng cho tôi biết trong phần bình luận!