【Java实习】Spring容器工具包

刺骨的言语ヽ痛彻心扉 2024-03-27 13:37 52阅读 0赞

开发SpringBoot项目，最方便的地方就在于我们可以很容易的获取到我们想要的bean对象。  
但是如果再不适用@Autowired或者@Resource注解的时候，我们就只能手动的创建一个容器对象，然后去获取这个  
容器中的bean，其实为什么不直接使用注解去自动注入一个对象的原因是因为，我们只想在我们想要用到这个对象的  
时候才需要这个对象，而如果平白无故的吧这个对象设定为我们类中的属性，耦合性更大，并且可能出现循环依赖。  
因此，不如编写一个工具类，来帮助我们方便的从容器中获取我们想要的对象，不是更好？

@Component 
    public final class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware 
    {
        
        /** Spring应用上下文环境 */
        private static ConfigurableListableBeanFactory beanFactory;
    
        private static ApplicationContext applicationContext;
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException 
        {
        
            SpringUtils.beanFactory = beanFactory;
        }
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException 
        {
        
            SpringUtils.applicationContext = applicationContext;
        }
    
        /**
         * 获取对象
         *
         * @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);
        }
    
        /**
         * 获取aop代理对象
         * 
         * @param invoker
         * @return
         */
        @SuppressWarnings("unchecked")
        public static <T> T getAopProxy(T invoker)
        {
        
            return (T) AopContext.currentProxy();
        }
    
        /**
         * 获取当前的环境配置，无配置返回null
         *
         * @return 当前的环境配置
         */
        public static String[] getActiveProfiles()
        {
        
            return applicationContext.getEnvironment().getActiveProfiles();
        }
    
        /**
         * 获取当前的环境配置，当有多个环境配置时，只获取第一个
         *
         * @return 当前的环境配置
         */
        public static String getActiveProfile()
        {
        
            final String[] activeProfiles = getActiveProfiles();
            return StringUtils.isNotEmpty(activeProfiles) ? activeProfiles[0] : null;
        }
    
        /**
         * 获取配置文件中的值
         *
         * @param key 配置文件的key
         * @return 当前的配置文件的值
         *
         */
        public static String getRequiredProperty(String key)
        {
        
            return applicationContext.getEnvironment().getRequiredProperty(key);
        }
    }

使用方法如下

// 插入数据
        SpringUtils.getBean(Logistics.class).insertLogistics(logistics);

并且，还有一个很重要的地方在于。  
我们不仅仅可以简答的获取到一个bean对象，我们还可以编写使用AOP去增强某个方法。  
具体原因可以先看一下这篇文章  
[SpringAop的小细节][SpringAop]  
这里以若依中的代码为例  
可以看到下面的那个方法，调用了上面的方法，而上面的方法单独调用的时候是会进行AOP的增强的。  
但是根据上面的理论，可以知道。如果使用下面的方法去调用下面的方法，是不会进行AOP的增强的。  
因此，为了解决这种问题，下面的方法获得到了一个AOP的代理对象，然后通过这个代理对象去调用了上面的方法。  
那么此时就依旧可以起到增强的效果。  
![在这里插入图片描述][d0218afcdb614b98ac08993caa1fd204.png]  
其中对上面的方法的增强的方式为前置增强，其通过监听所有方法，并检测方法上是否有controllerDataScope对应类型的注解来判断是否进行增强。也就是这个方法上是否使用了@DataScope注解，如果使用了，那么就会进行前置增强。  
![在这里插入图片描述][d0ba552d8f0f4034b25d206c21bebd1b.png]

[SpringAop]: https://blog.csdn.net/qq_29860591/article/details/108728150
[d0218afcdb614b98ac08993caa1fd204.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/3abebc95c26b4a1491f1184c05f64907.png
[d0ba552d8f0f4034b25d206c21bebd1b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/28a747329bff43098a21a8d4826fa8bb.png