update parameters

components/fluent-builtin/src/main/java/io/fluent/builtin/BigDecimalUtil.java

@@ -0,0 +1,17 @@
+package io.fluent.builtin;
+
+import java.math.BigDecimal;
+
+public class BigDecimalUtil {
+
+    //-1
+    public static final BigDecimal NEGATIVE_ONE = BigDecimal.valueOf(-1);
+    public static final BigDecimal ONE_HUNDRED = BigDecimal.valueOf(100);
+    public static final BigDecimal ONE_HUNDREDTH = new BigDecimal("0.01");
+    public static final BigDecimal HOUR_8 = BigDecimal.valueOf(8);
+
+    public static boolean isEmpty(BigDecimal bigDecimal) {
+
+        return bigDecimal == null || BigDecimal.ZERO.compareTo(bigDecimal) == 0;
+    }
+}

components/fluent-spring/pom.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>io.fluent</groupId>
+        <artifactId>components</artifactId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>fluent-spring</artifactId>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+    <dependencies>
+        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+            <version>6.1.11</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>6.1.11</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webmvc</artifactId>
+            <version>6.1.11</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context-support</artifactId>
+            <version>6.1.11</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/jakarta.servlet/jakarta.servlet-api -->
+        <dependency>
+            <groupId>jakarta.servlet</groupId>
+            <artifactId>jakarta.servlet-api</artifactId>
+            <version>6.1.0</version>
+            <scope>provided</scope>
+        </dependency>
+
+    </dependencies>
+</project>

components/fluent-spring/src/main/java/io/fluent/spring/config/SpringConfig.java

@@ -0,0 +1,12 @@
+package io.fluent.spring.config;
+
+import io.fluent.spring.util.SpringUtils;
+import org.springframework.context.annotation.Bean;
+
+
+public class SpringConfig {
+    @Bean("fluentSpringUtils")
+    public SpringUtils springUtils() {
+        return new SpringUtils();
+    }
+}

components/fluent-spring/src/main/java/io/fluent/spring/util/IpUtils.java

@@ -0,0 +1,177 @@
+package io.fluent.spring.util;
+
+
+import jakarta.servlet.http.HttpServletRequest;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Objects;
+
+/**
+ * 获取IP方法
+ */
+public class IpUtils {
+    public static String getIpAddr(HttpServletRequest request) {
+        if (Objects.isNull(request)) {
+            return "127.0.0.1";
+        }
+        String ip = null;
+
+        // X-Forwarded-For：Squid 服务代理
+        String ipAddresses = request.getHeader("X-Forwarded-For");
+        if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
+            // Proxy-Client-IP：apache 服务代理
+            ipAddresses = request.getHeader("Proxy-Client-IP");
+        }
+        if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
+            // WL-Proxy-Client-IP：weblogic 服务代理
+            ipAddresses = request.getHeader("WL-Proxy-Client-IP");
+        }
+        if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
+            // HTTP_CLIENT_IP：有些代理服务器
+            ipAddresses = request.getHeader("HTTP_CLIENT_IP");
+        }
+        if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
+            // X-Real-IP：nginx服务代理
+            ipAddresses = request.getHeader("X-Real-IP");
+        }
+
+        // 有些网络通过多层代理，那么获取到的ip就会有多个，一般都是通过逗号（,）分割开来，并且第一个ip为客户端的真实IP
+        if (ipAddresses != null && ipAddresses.length() != 0) {
+            ip = ipAddresses.split(",")[0];
+        }
+
+        // 还是不能获取到，最后再通过request.getRemoteAddr();获取
+        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
+            ip = request.getRemoteAddr();
+        }
+        return ip.equals("0:0:0:0:0:0:0:1") ? "127.0.0.1" : ip;
+    }
+
+    public static boolean internalIp(String ip) {
+        byte[] addr = textToNumericFormatV4(ip);
+        return internalIp(addr) || "127.0.0.1".equals(ip);
+    }
+
+    private static boolean internalIp(byte[] addr) {
+        if (addr == null || addr.length < 2) {
+            return true;
+        }
+        final byte b0 = addr[0];
+        final byte b1 = addr[1];
+        // 10.x.x.x/8
+        final byte SECTION_1 = 0x0A;
+        // 172.16.x.x/12
+        final byte SECTION_2 = (byte) 0xAC;
+        final byte SECTION_3 = (byte) 0x10;
+        final byte SECTION_4 = (byte) 0x1F;
+        // 192.168.x.x/16
+        final byte SECTION_5 = (byte) 0xC0;
+        final byte SECTION_6 = (byte) 0xA8;
+        switch (b0) {
+            case SECTION_1:
+                return true;
+            case SECTION_2:
+                if (b1 >= SECTION_3 && b1 <= SECTION_4) {
+                    return true;
+                }
+            case SECTION_5:
+                switch (b1) {
+                    case SECTION_6:
+                        return true;
+                }
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * 将IPv4地址转换成字节
+     *
+     * @param text IPv4地址
+     * @return byte 字节
+     */
+    public static byte[] textToNumericFormatV4(String text) {
+        if (text.length() == 0) {
+            return null;
+        }
+
+        byte[] bytes = new byte[4];
+        String[] elements = text.split("\\.", -1);
+        try {
+            long l;
+            int i;
+            switch (elements.length) {
+                case 1:
+                    l = Long.parseLong(elements[0]);
+                    if ((l < 0L) || (l > 4294967295L)) {
+                        return null;
+                    }
+                    bytes[0] = (byte) (int) (l >> 24 & 0xFF);
+                    bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
+                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
+                    bytes[3] = (byte) (int) (l & 0xFF);
+                    break;
+                case 2:
+                    l = Integer.parseInt(elements[0]);
+                    if ((l < 0L) || (l > 255L)) {
+                        return null;
+                    }
+                    bytes[0] = (byte) (int) (l & 0xFF);
+                    l = Integer.parseInt(elements[1]);
+                    if ((l < 0L) || (l > 16777215L)) {
+                        return null;
+                    }
+                    bytes[1] = (byte) (int) (l >> 16 & 0xFF);
+                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
+                    bytes[3] = (byte) (int) (l & 0xFF);
+                    break;
+                case 3:
+                    for (i = 0; i < 2; ++i) {
+                        l = Integer.parseInt(elements[i]);
+                        if ((l < 0L) || (l > 255L)) {
+                            return null;
+                        }
+                        bytes[i] = (byte) (int) (l & 0xFF);
+                    }
+                    l = Integer.parseInt(elements[2]);
+                    if ((l < 0L) || (l > 65535L)) {
+                        return null;
+                    }
+                    bytes[2] = (byte) (int) (l >> 8 & 0xFF);
+                    bytes[3] = (byte) (int) (l & 0xFF);
+                    break;
+                case 4:
+                    for (i = 0; i < 4; ++i) {
+                        l = Integer.parseInt(elements[i]);
+                        if ((l < 0L) || (l > 255L)) {
+                            return null;
+                        }
+                        bytes[i] = (byte) (int) (l & 0xFF);
+                    }
+                    break;
+                default:
+                    return null;
+            }
+        } catch (NumberFormatException e) {
+            return null;
+        }
+        return bytes;
+    }
+
+    public static String getHostIp() {
+        try {
+            return InetAddress.getLocalHost().getHostAddress();
+        } catch (UnknownHostException e) {
+        }
+        return "127.0.0.1";
+    }
+
+    public static String getHostName() {
+        try {
+            return InetAddress.getLocalHost().getHostName();
+        } catch (UnknownHostException e) {
+        }
+        return "未知";
+    }
+}

components/fluent-spring/src/main/java/io/fluent/spring/util/SpringRegisterUtil.java

@@ -0,0 +1,123 @@
+package io.fluent.spring.util;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.ReflectionUtils;
+import org.springframework.util.StringUtils;
+import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
+import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * 手动注入
+
+ */
+public class SpringRegisterUtil {
+
+    /**
+     * 向IOC 容器中注入 bean
+     *
+     * @param clazz    bean class
+     * @param beanName bean beanName
+     */
+    public static void registerBean(Class<?> clazz, String beanName) {
+        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
+        BeanDefinition beanDefinition = beanDefinitionBuilder.getRawBeanDefinition();
+        //设置当前bean定义对象是单利的
+        beanDefinition.setScope("singleton");
+        if (!StringUtils.hasText(beanName)) {
+            //将变量首字母置小写
+            beanName = StringUtils.uncapitalize(clazz.getSimpleName());
+            beanName = beanName.substring(beanName.lastIndexOf(".") + 1);
+            beanName = StringUtils.uncapitalize(beanName);
+        }
+
+        //将applicationContext转换为ConfigurableApplicationContext
+        ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) SpringUtils.getApplicationContext();
+        // 获取bean工厂并转换为DefaultListableBeanFactory
+        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();
+        defaultListableBeanFactory.registerBeanDefinition(beanName, beanDefinition);
+    }
+
+    /**
+     * 卸载bean
+     *
+     * @param className
+     * @throws Exception
+     */
+    public void unregisterBean(String className) throws Exception {
+
+        ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) SpringUtils.getApplicationContext();
+        // 获取bean工厂并转换为DefaultListableBeanFactory
+        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();
+        defaultListableBeanFactory.removeBeanDefinition(className);
+    }
+
+    /**
+     * 注册Controller
+     *
+     * @param controllerBeanName
+     * @throws NoSuchMethodException
+     * @throws InvocationTargetException
+     * @throws IllegalAccessException
+     */
+    public static void registerController(String controllerBeanName) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+
+        //先注册bean
+        //registerBean(controllerBeanName);
+
+        final RequestMappingHandlerMapping requestMappingHandlerMapping = SpringUtils.getBean(RequestMappingHandlerMapping.class);
+        String handler = controllerBeanName;
+        Object controller = SpringUtils.getBean(handler);
+        //            unregisterController(controllerBeanName);
+        if (controller == null) {
+            return;
+        }
+        //注册Controller
+        Method method = requestMappingHandlerMapping.getClass().getSuperclass().getSuperclass().
+                getDeclaredMethod("detectHandlerMethods", Object.class);
+        //将private改为可使用
+        method.setAccessible(true);
+        method.invoke(requestMappingHandlerMapping, controllerBeanName);
+    }
+
+    /**
+     * 去掉Controller的Mapping
+     *
+     * @param controllerBeanName
+     */
+    public static void unregisterController(String controllerBeanName) {
+        final RequestMappingHandlerMapping requestMappingHandlerMapping = (RequestMappingHandlerMapping)
+                SpringUtils.getBean("requestMappingHandlerMapping");
+        if (requestMappingHandlerMapping != null) {
+            String handler = controllerBeanName;
+            Object controller = SpringUtils.getBean(handler);
+            if (controller == null) {
+                return;
+            }
+            final Class<?> targetClass = controller.getClass();
+            ReflectionUtils.doWithMethods(targetClass, new ReflectionUtils.MethodCallback() {
+                public void doWith(Method method) {
+                    Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
+                    try {
+                        Method createMappingMethod = RequestMappingHandlerMapping.class.
+                                getDeclaredMethod("getMappingForMethod", Method.class, Class.class);
+                        createMappingMethod.setAccessible(true);
+                        RequestMappingInfo requestMappingInfo = (RequestMappingInfo)
+                                createMappingMethod.invoke(requestMappingHandlerMapping, specificMethod, targetClass);
+                        if (requestMappingInfo != null) {
+                            requestMappingHandlerMapping.unregisterMapping(requestMappingInfo);
+                        }
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+            }, ReflectionUtils.USER_DECLARED_METHODS);
+        }
+    }
+}