常用Java工具类：IPUtil、CollectionUtils、MDC、ClassUtils、BeanUtils、ReflectionUtils

# 常用工具类

除了我们前面提到的 Java 原生工具类，比如说 Arrays、Objects、Collections、Scanner 等，还有一些第三方的工具类，比如说 Hutool、Guava 等，以及我们今天介绍的 IpUtil、CollectionUtils、StringUtils、MDC、ClassUtils、BeanUtils、ReflectionUtils 等等，在很大程度上能够提高我们的生产效率。

当然了，如果能好好看一下它们的源码，对技术功底的提升，也是有很大帮助的。

# IpUtil：获取本机 Ip

获取本机 IP 算是比较常见的一个需求场景了，比如业务报警，可能就会带上出问题的机器 IP，方便直接上去看日志定位问题，那么问题来了，如何获取机器 IP 呢？

# 基本方法

如何获取机器 IP？如果了解 InetAddress 这个工具类，就很容易写出一个简单的工具类，如下

1
2
3
4
5
6
7
public static String getLocalIP() {
    try {
        return InetAddress.getLocalHost().getHostAddress();
    } catch (UnknownHostException e) {
        throw new RuntimeException(e);
    }
}

上面的实现有问题么？

当然没问题，拿我本机和阿里服务器执行一下，并没有问题如实的输出了预期的 IP

本机执行后截图如下：

阿里云机器执行后截图如下：

# 进阶版

做一点简单的改动，获取 IPV4 的地址，源码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public static String getLocalIpByNetcard() {
    try {
        // 枚举所有的网络接口
        for (Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces(); e.hasMoreElements(); ) {
            // 获取当前网络接口
            NetworkInterface item = e.nextElement();

            // 遍历当前网络接口的所有地址
            for (InterfaceAddress address : item.getInterfaceAddresses()) {
                // 忽略回环地址和未启用的网络接口
                if (item.isLoopback() || !item.isUp()) {
                    continue;
                }

                // 如果当前地址是 IPv4 地址，则返回其字符串表示
                if (address.getAddress() instanceof Inet4Address) {
                    Inet4Address inet4Address = (Inet4Address) address.getAddress();
                    return inet4Address.getHostAddress();
                }
            }
        }

        // 如果没有找到任何 IPv4 地址，则返回本地主机地址
        return InetAddress.getLocalHost().getHostAddress();
    } catch (SocketException | UnknownHostException e) {
        // 抛出运行时异常
        throw new RuntimeException(e);
    }
}

需要注意的是，这段代码只返回本机的 IPv4 地址，并且只返回第一个符合条件的地址。如果本机有多个网络接口或者每个接口有多个地址，则可能无法返回预期的地址。此外，如果找不到任何 IPv4 地址，则会返回本地主机地址。

再次测试，输出如下

# 完整工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import java.net.*;
import java.util.Enumeration;

public class IPUtil {
    public static final String DEFAULT_IP = "127.0.0.1";

    /**
     * 直接根据第一个网卡地址作为其内网ipv4地址，避免返回 127.0.0.1
     *
     * @return 第一个符合条件的内网 IPv4 地址
     */
    public static String getLocalIpByNetcard() {
        try {
            // 枚举所有的网络接口
            for (Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces(); e.hasMoreElements(); ) {
                // 获取当前网络接口
                NetworkInterface item = e.nextElement();
                // 遍历当前网络接口的所有地址
                for (InterfaceAddress address : item.getInterfaceAddresses()) {
                    // 忽略回环地址和未启用的网络接口
                    if (item.isLoopback() || !item.isUp()) {
                        continue;
                    }
                    // 如果当前地址是 IPv4 地址，则返回其字符串表示
                    if (address.getAddress() instanceof Inet4Address) {
                        Inet4Address inet4Address = (Inet4Address) address.getAddress();
                        return inet4Address.getHostAddress();
                    }
                }
            }
            // 如果没有找到符合条件的地址，则返回本地主机地址
            return InetAddress.getLocalHost().getHostAddress();
        } catch (SocketException | UnknownHostException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取本地主机地址
     *
     * @return 本地主机地址
     */
    public static String getLocalIP() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            throw new RuntimeException(e);
        }
    }
}

IPUtil 类中定义了两个方法，分别是 getLocalIpByNetcard() 和 getLocalIP() 。前者是获取本机的内网 IPv4 地址，避免了返回 127.0.0.1 的问题。后者是获取本地主机地址，如果本机有多个 IP 地址，则可能返回其中的任意一个。

# MDC：一个线程安全的参数传递工具类

MDC 是 org.slf4j 包下的一个类，它的全称是 Mapped Diagnostic Context，我们可以认为它是一个线程安全的存放诊断日志的容器。

MDC 的底层是用了 ThreadLocal 来保存数据的。

我们可以用它传递参数。

例如现在有这样一种场景：我们使用 RestTemplate 调用远程接口时，有时需要在 header 中传递信息，比如：traceId，source 等，便于在查询日志时能够串联一次完整的请求链路，快速定位问题。

这种业务场景就能通过 ClientHttpRequestInterceptor 接口实现，具体做法如下：

第一步，定义一个 LogFilter 拦截所有接口请求，在 MDC 中设置 traceId：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class LogFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        MdcUtil.add(UUID.randomUUID().toString());
        System.out.println("记录请求日志");
        chain.doFilter(request, response);
        System.out.println("记录响应日志");
    }

    @Override
    public void destroy() {
    }
}

第二步，实现 ClientHttpRequestInterceptor 接口，MDC 中获取当前请求的 traceId，然后设置到 header 中：

1
2
3
4
5
6
7
8
public class RestTemplateInterceptor implements ClientHttpRequestInterceptor {

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        request.getHeaders().set("traceId", MdcUtil.get());
        return execution.execute(request, body);
    }
}

第三步，定义配置类，配置上面定义的 RestTemplateInterceptor 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Configuration
public class RestTemplateConfiguration {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setInterceptors(Collections.singletonList(restTemplateInterceptor()));
        return restTemplate;
    }

    @Bean
    public RestTemplateInterceptor restTemplateInterceptor() {
        return new RestTemplateInterceptor();
    }
}

其中 MdcUtil 其实是利用 MDC 工具在 ThreadLocal 中存储和获取 traceId

1
2
3
4
5
6
7
8
9
10
11
12
public class MdcUtil {

    private static final String TRACE_ID = "TRACE_ID";

    public static String get() {
        return MDC.get(TRACE_ID);
    }

    public static void add(String value) {
        MDC.put(TRACE_ID, value);
    }
}

当然，这个例子中没有演示 MdcUtil 类的 add 方法具体调的地方，我们可以在 filter 中执行接口方法之前，生成 traceId，调用 MdcUtil 类的 add 方法添加到 MDC 中，然后在同一个请求的其他地方就能通过 MdcUtil 类的 get 方法获取到该 traceId。

能使用 MDC 保存 traceId 等参数的根本原因是，用户请求到应用服务器，Tomcat 会从线程池中分配一个线程去处理该请求。

那么该请求的整个过程中，保存到 MDC 的 ThreadLocal 中的参数，也是该线程独享的，所以不会有线程安全问题。

# ClassUtils

spring 的 org.springframework.util 包下的 ClassUtils 类，它里面有很多让我们惊喜的功能。

它里面包含了类和对象相关的很多非常实用的方法。

# 获取对象的所有接口

如果你想获取某个对象的所有接口，可以使用 ClassUtils 的 getAllInterfaces 方法。例如：

1
Class<?>[] allInterfaces = ClassUtils.getAllInterfaces(new User());

# 获取某个类的包名

如果你想获取某个类的包名，可以使用 ClassUtils 的 getPackageName 方法。例如：

1
2
String packageName = ClassUtils.getPackageName(User.class);
System.out.println(packageName);

# 判断某个类是否内部类

如果你想判断某个类是否内部类，可以使用 ClassUtils 的 isInnerClass 方法。例如：

1
System.out.println(ClassUtils.isInnerClass(User.class));

# 判断对象是否代理对象

如果你想判断对象是否代理对象，可以使用 ClassUtils 的 isCglibProxy 方法。例如：

1
System.out.println(ClassUtils.isCglibProxy(new User()));

ClassUtils 还有很多有用的方法，等待着你去发掘。感兴趣的小伙伴，可以看看下面的内容：

# BeanUtils

Spring 给我们提供了一个 JavaBean 的工具类，它在 org.springframework.beans 包下面，它的名字叫做： BeanUtils 。

让我们一起看看这个工具可以带给我们哪些惊喜。

# 拷贝对象的属性

曾几何时，你有没有这样的需求：把某个对象中的所有属性，都拷贝到另外一个对象中。这时就能使用 BeanUtils 的 copyProperties 方法。例如：

1
2
3
4
5
6
7
8
User user1 = new User();
user1.setId(1L);
user1.setName("马斯克");
user1.setAddress("中国");

User user2 = new User();
BeanUtils.copyProperties(user1, user2);
System.out.println(user2);

# 实例化某个类

如果你想通过反射实例化一个类的对象，可以使用 BeanUtils 的 instantiateClass 方法。例如：

1
2
User user = BeanUtils.instantiateClass(User.class);
System.out.println(user);

# 获取指定类的指定方法

如果你想获取某个类的指定方法，可以使用 BeanUtils 的 findDeclaredMethod 方法。例如：

1
2
Method declaredMethod = BeanUtils.findDeclaredMethod(User.class, "getId");
System.out.println(declaredMethod.getName());

# 获取指定方法的参数

如果你想获取某个方法的参数，可以使用 BeanUtils 的 findPropertyForMethod 方法。例如：

1
2
3
Method declaredMethod = BeanUtils.findDeclaredMethod(User.class, "getId");
PropertyDescriptor propertyForMethod = BeanUtils.findPropertyForMethod(declaredMethod);
System.out.println(propertyForMethod.getName());

如果你对 BeanUtils 比较感兴趣，可以看看下面内容：

# ReflectionUtils

有时候，我们需要在项目中使用 反射 功能，如果使用最原始的方法来开发，代码量会非常多，而且很麻烦，它需要处理一大堆异常以及访问权限等问题。

好消息是 Spring 给我们提供了一个 ReflectionUtils 工具，它在 org.springframework.util 包下面。

# 获取方法

如果你想获取某个类的某个方法，可以使用 ReflectionUtils 类的 findMethod 方法。例如：

1
Method method = ReflectionUtils.findMethod(User.class, "getId");

# 获取字段

如果你想获取某个类的某个字段，可以使用 ReflectionUtils 类的 findField 方法。例如：

1
Field field = ReflectionUtils.findField(User.class, "id");

# 执行方法

如果你想通过反射调用某个方法，传递参数，可以使用 ReflectionUtils 类的 invokeMethod 方法。例如：

1
ReflectionUtils.invokeMethod(method, springContextsUtil.getBean(beanName), param);

# 判断字段是否常量

如果你想判断某个字段是否常量，可以使用 ReflectionUtils 类的 isPublicStaticFinal 方法。例如：

1
2
Field field = ReflectionUtils.findField(User.class, "id");
System.out.println(ReflectionUtils.isPublicStaticFinal(field));

# 判断是否 equals 方法

如果你想判断某个方法是否 equals 方法，可以使用 ReflectionUtils 类的 isEqualsMethod 方法。例如：

1
2
Method method = ReflectionUtils.findMethod(User.class, "getId");
System.out.println(ReflectionUtils.isEqualsMethod(method));