ruoyi的spring cloud项目详解（九）

阿贾克斯的黎明

于 2024-09-01 00:03:52 发布

阅读量740

点赞数 21

分类专栏： java 文章标签： spring cloud spring 后端

本文链接：https://blog.csdn.net/m0_57836225/article/details/141760734

版权

java 专栏收录该内容

74 篇文章 0 订阅

订阅专栏

书接上回

ruoyi的spring cloud项目详解（八）-CSDN博客

虽然工具类的代码和业务逻辑代码不一样，工具类的代码都是CV吧，但还是学习一下吧，顺便记一下笔记

com/ruoyi/common/utils/security/Md5Utils.java

package com.ruoyi.common.utils.security;

import java.security.MessageDigest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Md5加密方法
 * 
 * @author ruoyi
 */
public class Md5Utils
{
    private static final Logger log = LoggerFactory.getLogger(Md5Utils.class);

    private static byte[] md5(String s)
    {
        MessageDigest algorithm;
        try
        {
            algorithm = MessageDigest.getInstance("MD5");
            algorithm.reset();
            algorithm.update(s.getBytes("UTF-8"));
            byte[] messageDigest = algorithm.digest();
            return messageDigest;
        }
        catch (Exception e)
        {
            log.error("MD5 Error...", e);
        }
        return null;
    }

    private static final String toHex(byte hash[])
    {
        if (hash == null)
        {
            return null;
        }
        StringBuffer buf = new StringBuffer(hash.length * 2);
        int i;

        for (i = 0; i < hash.length; i++)
        {
            if ((hash[i] & 0xff) < 0x10)
            {
                buf.append("0");
            }
            buf.append(Long.toString(hash[i] & 0xff, 16));
        }
        return buf.toString();
    }

    public static String hash(String s)
    {
        try
        {
            return new String(toHex(md5(s)).getBytes("UTF-8"), "UTF-8");
        }
        catch (Exception e)
        {
            log.error("not supported charset...{}", e);
            return s;
        }
    }
}

以下是代码拆分及分析：

1. 导入相关包

import java.security.MessageDigest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

这部分代码导入了进行 MD5 加密所需的MessageDigest类以及用于日志记录的Logger和LoggerFactory。

2. 定义工具类

/**
 * Md5加密方法
 * 
 * @author ruoyi
 */
public class Md5Utils
{

这是一个名为Md5Utils的工具类，用于提供 MD5 加密功能。注释中说明了该类的用途以及作者信息。

3. 定义日志对象

    private static final Logger log = LoggerFactory.getLogger(Md5Utils.class);

这里创建了一个静态的Logger对象，用于在类的方法中记录日志。通过LoggerFactory.getLogger(Md5Utils.class)获取与当前类对应的日志记录器。

4. md5方法

    private static byte[] md5(String s)
    {
        MessageDigest algorithm;
        try
        {
            algorithm = MessageDigest.getInstance("MD5");
            algorithm.reset();
            algorithm.update(s.getBytes("UTF-8"));
            byte[] messageDigest = algorithm.digest();
            return messageDigest;
        }
        catch (Exception e)
        {
            log.error("MD5 Error...", e);
        }
        return null;
    }

这个私有静态方法接受一个字符串参数s，用于执行 MD5 加密操作。首先尝试获取MessageDigest实例并指定加密算法为"MD5"，然后重置实例、更新输入字符串的字节数组并进行加密，最后返回加密后的字节数组。如果出现异常，则记录错误日志并返回null。

5. toHex方法

    private static final String toHex(byte hash[])
    {
        if (hash == null)
        {
            return null;
        }
        StringBuffer buf = new StringBuffer(hash.length * 2);
        int i;

        for (i = 0; i < hash.length; i++)
        {
            if ((hash[i] & 0xff) < 0x10)
            {
                buf.append("0");
            }
            buf.append(Long.toString(hash[i] & 0xff, 16));
        }
        return buf.toString();
    }

这个私有静态方法接受一个字节数组参数hash，用于将加密后的字节数组转换为十六进制字符串表示。如果输入的字节数组为null，则直接返回null。否则，创建一个StringBuffer对象用于构建十六进制字符串，遍历字节数组，对每个字节进行处理，将其转换为十六进制并添加到StringBuffer中，最后返回构建好的十六进制字符串。

6. hash方法

    public static String hash(String s)
    {
        try
        {
            return new String(toHex(md5(s)).getBytes("UTF-8"), "UTF-8");
        }
        catch (Exception e)
        {
            log.error("not supported charset...{}", e);
            return s;
        }
    }
}

这个公共静态方法是对外公开的，用于对输入字符串进行 MD5 加密并返回加密后的十六进制字符串。首先调用md5方法进行加密，然后将加密结果传递给toHex方法转换为十六进制字符串，接着尝试将十六进制字符串转换为字节数组（使用"UTF-8"编码），最后再转换回字符串（同样使用"UTF-8"编码）并返回。如果出现异常，则记录错误日志并返回输入的字符串s。

这段 Java 代码实现了一个 MD5 加密工具类Md5Utils，主要功能总结如下：

功能概述

提供了对字符串进行 MD5 加密并以十六进制字符串形式返回结果的功能。

关键实现步骤

通过LoggerFactory.getLogger(Md5Utils.class)获取日志记录器，用于记录加密过程中的错误信息。
md5方法：
- 尝试获取MessageDigest实例并指定为 MD5 算法。
- 重置实例后，使用 UTF-8 编码将输入字符串转换为字节数组并更新加密器。
- 进行加密操作并返回加密后的字节数组，出现异常时记录错误日志并返回null。
toHex方法：
- 将加密后的字节数组转换为十六进制字符串表示。
- 对字节数组中的每个字节进行处理，小于0x10时在前面添加"0"，然后转换为十六进制字符串并添加到结果中。
hash方法：
- 调用md5方法进行加密，再将结果传递给toHex方法转换为十六进制字符串。
- 将十六进制字符串转换为字节数组（UTF-8 编码）后再转换回字符串（UTF-8 编码）并返回，出现异常时记录错误日志并返回输入字符串。

用途

可用于需要对敏感信息（如密码）进行加密存储或数据完整性校验等场景，提高数据的安全性。

咱们接着看

package com.ruoyi.common.utils.security;

import org.apache.commons.lang3.StringUtils;
import com.ruoyi.common.constant.PermissionConstants;
import com.ruoyi.common.utils.MessageUtils;

/**
 * permission 工具类
 * 
 * @author ruoyi
 */
public class PermissionUtils
{
    /**
     * 查看数据的权限
     */
    public static final String VIEW_PERMISSION = "no.view.permission";

    /**
     * 创建数据的权限
     */
    public static final String CREATE_PERMISSION = "no.create.permission";

    /**
     * 修改数据的权限
     */
    public static final String UPDATE_PERMISSION = "no.update.permission";

    /**
     * 删除数据的权限
     */
    public static final String DELETE_PERMISSION = "no.delete.permission";

    /**
     * 导出数据的权限
     */
    public static final String EXPORT_PERMISSION = "no.export.permission";

    /**
     * 其他数据的权限
     */
    public static final String PERMISSION = "no.permission";

    /**
     * 权限错误消息提醒
     * 
     * @param permissionsStr 错误信息
     * @return 提示信息
     */
    public static String getMsg(String permissionsStr)
    {
        String permission = StringUtils.substringBetween(permissionsStr, "[", "]");
        String msg = MessageUtils.message(PERMISSION, permission);
        if (StringUtils.endsWithIgnoreCase(permission, PermissionConstants.ADD_PERMISSION))
        {
            msg = MessageUtils.message(CREATE_PERMISSION, permission);
        }
        else if (StringUtils.endsWithIgnoreCase(permission, PermissionConstants.EDIT_PERMISSION))
        {
            msg = MessageUtils.message(UPDATE_PERMISSION, permission);
        }
        else if (StringUtils.endsWithIgnoreCase(permission, PermissionConstants.REMOVE_PERMISSION))
        {
            msg = MessageUtils.message(DELETE_PERMISSION, permission);
        }
        else if (StringUtils.endsWithIgnoreCase(permission, PermissionConstants.EXPORT_PERMISSION))
        {
            msg = MessageUtils.message(EXPORT_PERMISSION, permission);
        }
        else if (StringUtils.endsWithAny(permission,
                new String[] { PermissionConstants.VIEW_PERMISSION, PermissionConstants.LIST_PERMISSION }))
        {
            msg = MessageUtils.message(VIEW_PERMISSION, permission);
        }
        return msg;
    }
}

以下是对这段代码的分段解析：

package com.ruoyi.common.utils.security;

import org.apache.commons.lang3.StringUtils;
import com.ruoyi.common.constant.PermissionConstants;
import com.ruoyi.common.utils.MessageUtils;

这段代码是导入所需的包，以便在后续的代码中使用。StringUtils来自org.apache.commons.lang3包，用于进行字符串操作。PermissionConstants可能是自定义的常量类，用于权限相关的常量定义。MessageUtils可能是一个工具类，用于处理消息相关的操作。

/**
 * permission 工具类
 * 
 * @author ruoyi
 */
public class PermissionUtils

这是一个名为PermissionUtils的工具类的声明，注释中表明它是用于处理权限相关的工具类，并且给出了作者信息。

    /**
     * 查看数据的权限
     */
    public static final String VIEW_PERMISSION = "no.view.permission";

    /**
     * 创建数据的权限
     */
    public static final String CREATE_PERMISSION = "no.create.permission";

    /**
     * 修改数据的权限
     */
    public static final String UPDATE_PERMISSION = "no.update.permission";

    /**
     * 删除数据的权限
     */
    public static final String DELETE_PERMISSION = "no.delete.permission";

    /**
     * 导出数据的权限
     */
    public static final String EXPORT_PERMISSION = "no.export.permission";

    /**
     * 其他数据的权限
     */
    public static final String PERMISSION = "no.permission";

这里定义了一系列的常量，分别代表不同类型的权限错误消息的键。例如，VIEW_PERMISSION表示查看数据权限错误的消息键。

    /**
     * 权限错误消息提醒
     * 
     * @param permissionsStr 错误信息
     * @return 提示信息
     */
    public static String getMsg(String permissionsStr)
    {
        String permission = StringUtils.substringBetween(permissionsStr, "[", "]");
        String msg = MessageUtils.message(PERMISSION, permission);
        if (StringUtils.endsWithIgnoreCase(permission, PermissionConstants.ADD_PERMISSION))
        {
            msg = MessageUtils.message(CREATE_PERMISSION, permission);
        }
        else if (StringUtils.endsWithIgnoreCase(permission, PermissionConstants.EDIT_PERMISSION))
        {
            msg = MessageUtils.message(UPDATE_PERMISSION, permission);
        }
        else if (StringUtils.endsWithIgnoreCase(permission, PermissionConstants.REMOVE_PERMISSION))
        {
            msg = MessageUtils.message(DELETE_PERMISSION, permission);
        }
        else if (StringUtils.endsWithIgnoreCase(permission, PermissionConstants.EXPORT_PERMISSION))
        {
            msg = MessageUtils.message(EXPORT_PERMISSION, permission);
        }
        else if (StringUtils.endsWithAny(permission,
                new String[] { PermissionConstants.VIEW_PERMISSION, PermissionConstants.LIST_PERMISSION }))
        {
            msg = MessageUtils.message(VIEW_PERMISSION, permission);
        }
        return msg;
    }

这个方法getMsg用于根据传入的权限错误信息字符串生成相应的提示信息。首先，使用StringUtils.substringBetween方法从传入的字符串中提取出位于[和]之间的部分，得到具体的权限字符串。然后，默认情况下，使用MessageUtils.message方法和PERMISSION常量以及提取出的权限字符串生成一个消息。接着，通过一系列的条件判断，如果权限字符串以特定的后缀结尾，就使用对应的常量和权限字符串调用MessageUtils.message方法生成特定类型的权限错误提示信息。最后，返回生成的提示信息。

整体功能

这段 Java 代码定义了一个名为PermissionUtils的工具类，主要用于处理权限相关的操作和消息提示。

代码结构和主要成员变量

导入了必要的包：org.apache.commons.lang3.StringUtils用于字符串操作，com.ruoyi.common.constant.PermissionConstants和com.ruoyi.common.utils.MessageUtils可能分别用于权限常量和消息处理。
定义了一系列常量：
- VIEW_PERMISSION：表示查看数据的权限错误消息的键。
- CREATE_PERMISSION：创建数据的权限错误消息的键。
- UPDATE_PERMISSION：修改数据的权限错误消息的键。
- DELETE_PERMISSION：删除数据的权限错误消息的键。
- EXPORT_PERMISSION：导出数据的权限错误消息的键。
- PERMISSION：其他数据的权限错误消息的键。
定义了一个方法：
- getMsg(String permissionsStr)：该方法接受一个包含权限错误信息的字符串，通过解析这个字符串提取出具体的权限部分，然后根据权限的类型调用MessageUtils.message()方法获取相应的提示信息并返回。如果权限字符串以特定的后缀结尾，如ADD_PERMISSION、EDIT_PERMISSION等，会分别对应创建、修改等不同的权限提示消息。

用途

这个工具类可以在需要进行权限检查和错误消息提示的应用场景中使用，帮助开发人员更方便地处理权限相关的问题并提供清晰的错误提示信息给用户。

咱们接着看

package com.ruoyi.common.utils.spring;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
@Lazy(false)
public class SpringContextHolder implements ApplicationContextAware, DisposableBean
{
    private static ApplicationContext applicationContext = null;

    /**
     * 取得存储在静态变量中的ApplicationContext.
     */
    public static ApplicationContext getApplicationContext()
    {
        return applicationContext;
    }

    /**
     * 实现ApplicationContextAware接口, 注入Context到静态变量中.
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
    {
        SpringContextHolder.applicationContext = applicationContext;
    }

    /**
     * 清除SpringContextHolder中的ApplicationContext为Null.
     */
    public static void clearHolder()
    {
        if (log.isDebugEnabled())
        {
            log.debug("清除SpringContextHolder中的ApplicationContext:" + applicationContext);
        }
        applicationContext = null;
    }

    /**
     * 发布事件
     *
     * @param event
     */
    public static void publishEvent(ApplicationEvent event)
    {
        if (applicationContext == null)
        {
            return;
        }
        applicationContext.publishEvent(event);
    }

    /**
     * 实现DisposableBean接口, 在Context关闭时清理静态变量.
     */
    @Override
    @SneakyThrows
    public void destroy()
    {
        SpringContextHolder.clearHolder();
    }
}

以下是对这段代码的分段解析：

package com.ruoyi.common.utils.spring;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

这段代码是导入所需的包和注解，以便在后续的代码中使用。引入了与 Spring 相关的ApplicationContext、DisposableBean、ApplicationContextAware和ApplicationEvent类，以及Lazy注解用于延迟加载、Service注解用于标识这是一个服务类、SneakyThrows和Slf4j注解用于日志记录和异常处理。

@Slf4j
@Service
@Lazy(false)
public class SpringContextHolder implements ApplicationContextAware, DisposableBean

这是一个名为SpringContextHolder的类的声明，使用了@Slf4j注解进行日志记录，@Service注解标识为一个服务类，@Lazy(false)表示不延迟加载这个类。这个类实现了ApplicationContextAware接口和DisposableBean接口。

    private static ApplicationContext applicationContext = null;

定义了一个静态变量applicationContext，用于存储ApplicationContext对象，初始值为null。

    /**
     * 取得存储在静态变量中的ApplicationContext.
     */
    public static ApplicationContext getApplicationContext()
    {
        return applicationContext;
    }

这是一个静态方法，用于获取存储在静态变量中的ApplicationContext对象。

    /**
     * 实现ApplicationContextAware接口, 注入Context到静态变量中.
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
    {
        SpringContextHolder.applicationContext = applicationContext;
    }

这个方法是实现ApplicationContextAware接口的方法，用于将传入的ApplicationContext对象注入到静态变量中。

    /**
     * 清除SpringContextHolder中的ApplicationContext为Null.
     */
    public static void clearHolder()
    {
        if (log.isDebugEnabled())
        {
            log.debug("清除SpringContextHolder中的ApplicationContext:" + applicationContext);
        }
        applicationContext = null;
    }

这个静态方法用于清除静态变量中的ApplicationContext，将其设置为null。如果日志处于调试模式，则会记录清除的信息。

    /**
     * 发布事件
     *
     * @param event
     */
    public static void publishEvent(ApplicationEvent event)
    {
        if (applicationContext == null)
        {
            return;
        }
        applicationContext.publishEvent(event);
    }

这个静态方法用于发布一个ApplicationEvent事件。如果applicationContext为null，则直接返回；否则，使用applicationContext发布事件。

    /**
     * 实现DisposableBean接口, 在Context关闭时清理静态变量.
     */
    @Override
    @SneakyThrows
    public void destroy()
    {
        SpringContextHolder.clearHolder();
    }

这个方法是实现DisposableBean接口的方法，在ApplicationContext关闭时被调用，用于清理静态变量中的ApplicationContext。使用了@SneakyThrows注解来处理可能抛出的异常。

总之：

以上Java 代码实现了一个名为SpringContextHolder的工具类，主要功能如下：

一、功能概述

提供了一种在 Spring 应用程序中方便地获取应用上下文（ApplicationContext）、发布事件以及在应用上下文关闭时进行清理的机制。

二、关键功能点

存储和获取应用上下文：
- 通过静态变量applicationContext存储ApplicationContext。
- 提供了静态方法getApplicationContext()用于获取存储的应用上下文。
- 实现了ApplicationContextAware接口的setApplicationContext()方法，在 Spring 容器初始化时将应用上下文注入到静态变量中。
发布事件：
- 提供了静态方法publishEvent(ApplicationEvent event)，用于在有事件发生时发布事件。如果应用上下文为null则不进行发布操作。
清理操作：
- 实现了DisposableBean接口的destroy()方法，在 Spring 容器关闭时被调用。
- destroy()方法调用clearHolder()方法将存储的应用上下文置为null，并在日志处于调试模式时记录清理操作的信息。

三、用途

在 Spring 应用程序中，这个工具类可以方便地在不同的地方获取应用上下文，进行事件发布以及确保在应用上下文关闭时进行适当的清理操作，有助于提高代码的可维护性和可扩展性。

接着看：

package com.ruoyi.common.utils.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

/**
 * spring工具类 方便在非spring管理环境中获取bean
 * 
 * @author ruoyi
 */
@Component
public final class SpringUtils implements BeanFactoryPostProcessor
{
    /** Spring应用上下文环境 */
    private static ConfigurableListableBeanFactory beanFactory;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
    {
        SpringUtils.beanFactory = beanFactory;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws org.springframework.beans.BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException
    {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws org.springframework.beans.BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException
    {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name)
    {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getAliases(name);
    }
}

以下是对这段代码的分段分析：

收起

java

复制

package com.ruoyi.common.utils.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

这段代码导入了所需的类和接口，并声明了包名。引入了与 Spring 相关的BeansException用于处理 bean 相关的异常、NoSuchBeanDefinitionException在找不到特定 bean 定义时抛出、BeanFactoryPostProcessor用于在 Spring 容器初始化 bean 工厂后进行处理、ConfigurableListableBeanFactory代表可配置的可列出 bean 的工厂，以及@Component注解用于将类标记为 Spring 组件以便被自动扫描和管理。

收起

java

复制

/**
 * spring工具类 方便在非spring管理环境中获取bean
 * 
 * @author ruoyi
 */
@Component
public final class SpringUtils implements BeanFactoryPostProcessor

这是一个名为SpringUtils的类声明，使用@Component注解标记为 Spring 组件，并且实现了BeanFactoryPostProcessor接口。注释中说明了该类的用途以及作者信息。

收起

java

复制

    /** Spring应用上下文环境 */
    private static ConfigurableListableBeanFactory beanFactory;

定义了一个静态私有变量beanFactory，用于存储ConfigurableListableBeanFactory，代表 Spring 应用上下文环境。

收起

java

复制

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
    {
        SpringUtils.beanFactory = beanFactory;
    }

这是实现BeanFactoryPostProcessor接口的方法，在 Spring 容器初始化 bean 工厂后被调用。将传入的beanFactory赋值给静态变量，以便在其他静态方法中使用。

收起

java

复制

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws org.springframework.beans.BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException
    {
        return (T) beanFactory.getBean(name);
    }

这个静态方法用于根据 bean 的名称获取 bean 的实例，并进行了类型转换。使用了@SuppressWarnings("unchecked")注解来抑制未检查的类型转换警告。如果找不到对应的 bean，则会抛出BeansException异常。

收起

java

复制

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws org.springframework.beans.BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException
    {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

另一个重载的静态方法，用于根据类的类型获取 bean 的实例。同样如果找不到对应的 bean，则会抛出BeansException异常。

收起

java

复制

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name)
    {
        return beanFactory.containsBean(name);
    }

这个静态方法用于判断 Spring 容器中是否包含指定名称的 bean。

收起

java

复制

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.isSingleton(name);
    }

这个静态方法用于判断指定名称的 bean 是否是单例的，如果 bean 不存在则抛出NoSuchBeanDefinitionException异常。

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getType(name);
    }

这个静态方法用于获取指定名称的 bean 的类型，如果 bean 不存在则抛出异常。

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getAliases(name);
    }

这个静态方法用于获取指定名称的 bean 的别名，如果 bean 不存在则抛出异常。

以上Java 代码实现了一个名为SpringUtils的工具类，主要功能如下：

功能概述

提供了在非 Spring 管理的环境中获取 Spring 容器中的 bean 以及查询 bean 相关信息的功能。

关键实现步骤

实现了BeanFactoryPostProcessor接口，在 Spring 容器初始化 bean 工厂后，将ConfigurableListableBeanFactory存储在静态变量beanFactory中。
提供了一系列静态方法：
- getBean(String name)：根据 bean 的名称获取 bean 的实例，并进行类型转换。
- getBean(Class<T> clz)：根据类的类型获取 bean 的实例。
- containsBean(String name)：判断 Spring 容器中是否包含指定名称的 bean。
- isSingleton(String name)：判断指定名称的 bean 是否是单例的，找不到 bean 时会抛出异常。
- getType(String name)：获取指定名称的 bean 的类型，找不到 bean 时会抛出异常。
- getAliases(String name)：获取指定名称的 bean 的别名，找不到 bean 时会抛出异常。

用途

在一些特殊情况下，如非 Spring 管理的代码中，可以使用这个工具类方便地获取 Spring 容器中的 bean，并查询 bean 的相关信息，提高了代码的灵活性和可复用性。

阿贾克斯的黎明

关注

21
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
ruoyi的spring cloud项目详解（九）

在一些特殊情况下，如非 Spring 管理的代码中，可以使用这个工具类方便地获取 Spring 容器中的 bean，并查询 bean 的相关信息，提高了代码的灵活性和可复用性。在 Spring 应用程序中，这个工具类可以方便地在不同的地方获取应用上下文，进行事件发布以及确保在应用上下文关闭时进行适当的清理操作，有助于提高代码的可维护性和可扩展性。接着，通过一系列的条件判断，如果权限字符串以特定的后缀结尾，就使用对应的常量和权限字符串调用。另一个重载的静态方法，用于根据类的类型获取 bean 的实例。
复制链接

扫一扫

专栏目录