java bean注入之静态注入

最新推荐文章于 2025-03-28 14:45:02 发布
最新推荐文章于 2025-03-28 14:45:02 发布
阅读量5.5k 收藏 4
点赞数 1
分类专栏： Java基础 Spring机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013631223/article/details/79280899
版权
本文详细介绍了Java Bean在Spring框架中的注入方式，包括XML配置中的属性注入、构造方法注入和工厂方法注入，以及注解方式的@Autowired、@Qualifier和@Resource的使用。通过实例展示了如何通过XML配置和注解定义Bean，以及启动Spring容器。文章强调了注解注入的灵活性和便利性，同时也讨论了@Autowired和@Resource的区别及其生效条件。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Java bean之容器调用机制


作为java程序控制层数据交互部分的缓存，java bean的加载方式如上图所示，Spring容器根据xml <bean>标签的写入、java中的@configuration、@bean、@autowrite注解等信息，将相关的java bean的信息注册在容器的注册表中。之后Spring容器会根据注册表的信息将注册表中的bean类进行实例化，并将实例化后的bean对象与java程序中的bean实例绑定放入容器中，形成一个bean的缓存池，当java应用程序需要调用bean实例时，Spring容器会直接根据索引在缓存池中调用相应的bean实例。

1、bean的定义

bean的配置有三种方式：1、在xml文件中配置，2、使用注解定义并自动装配，3、基于java类提供Bean定义信息

 基于xml文件的配置

 对于基于XML的配置，Spring 2.0以后使用Schema的格式，使得不同类型的配置拥有了自己的命名空间，是配置文件更具扩展性。

①默认命名空间：它没有空间名，用于Spring Bean的定义；

②xsi命名空间：这个命名空间用于为每个文档中命名空间指定相应的Schema样式文件，是标准组织定义的标准命名空间；

③aop命名空间：这个命名空间是Spring配置AOP的命名空间，是用户自定义的命名空间。

命名空间的定义分为两个步骤：第一步指定命名空间的名称；第二步指定命名空间的Schema文档样式文件的位置，用空格或回车换行进行分分隔。

在Spring容器的配置文件中定义一个简要Bean的配置片段如下所示：

一般情况下，Spring IOC容器中的一个Bean即对应配置文件中的一个<bean>。其中id为这个Bean的标识，通过容器的getBean()即可获取对应的Bean，在容器中起到定位查找的作用，是外部程序和Spring IOC容器进行交互的桥梁。class属性指定了Bean对应的实现类。getBean的入参包括name、requiredType、args；其中name不可为空，对应的是xml文件中<bean>的id，requiredType可为空，对应的是<bean>标签的class，标明这个bean的类型，传入格式为类对象形式，即 类名.class形式。

使用注解配置信息启动spring容器

Spring提供了一个context的命名空间，它提供了通过扫描类包以应用注解定义Bean的方式：

复制代码 
<?xml version="1.0" encoding="UTF-8" ?>
<!--①声明context的命名空间-->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd"
         >
    <!--②扫描类包以应用注解定义的Bean-->
   <context:component-scan base-package="com.baobaotao.anno"/>
   <bean class="com.baobaotao.anno.LogonService"></bean>
   <!-- context:component-scan base-package="com.baobaotao" resource-pattern="anno/*.class"/ -->
   <!-- context:component-scan base-package="com.baobaotao">
       <context:include-filter type="regex" expression="com\.baobaotao\.anno.*Dao"/>
       <context:include-filter type="regex" expression="com\.baobaotao\.anno.*Service"/>
       <context:exclude-filter type="aspectj" expression="com.baobaotao..*Controller+"/>
   </context:component-scan -->
</beans>
复制代码

在①处声明context命名空间，在②处即可通过context命名空间的component-scan的base-package属性指定一个需要扫描的基类包，Spring容器将会扫描这个基类包里的所有类，并从类的注解信息中获取Bean的定义信息。

如果仅希望扫描特定的类而非基包下的所有类，你们可以使用resource-pattern属性过滤特定的类，如下所示：

< context:component-scan base-package="com.baobaotao" resource-pattern="anno/*.class"/ >

这里我们将基类包设置为com.baobaotao，默认情况下resource-pattern属性的值为"**/*.class"，即基类包里的所有类。这里我们设置为"anno/*.class",则Spring仅会扫描基包里anno子包中的类。

Bean注入

传统方式下是在XML中配置，此时分别有属性注入、构造函数注入和工厂方法注入

属性注入

属性注入即通过setXxx()方法注入Bean的属性值或依赖对象，由于属性注入方式具有可选择性和灵活性高的优点，因此属性注入是实际应用中最常采用的注入方式。

属性注入要求Bean提供一个默认的构造函数，并为需要注入的属性提供对应的Setter方法。Spring先调用Bean的默认构造函数实例化Bean对象，然后通过反射的方式调用Setter方法注入属性值。

复制代码 
package com.baobaotao.anno;

import org.springframework.beans.factory.BeanNameAware;

public class LogonService implements BeanNameAware{

    private LogDao logDao;
    private UserDao userDao;
    private String value;
public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void setLogDao(LogDao logDao) { this.logDao = logDao; } 
    public void setValue(String value) {
        this.value = value;
    }
public LogDao getLogDao() { return logDao; } public UserDao getUserDao() { return userDao; } 
    public String getValue() {
  
 
 
        return value;
 } 
 

}
 
 
 
  复制代码 
 
 

 

bean.xml配置
 

 
 
 
  复制代码 
 
 
 
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd"
       default-autowire="byName"
         >
    <bean id="logDao" class="com.baobaotao.anno.LogDao"/>
    <bean id="userDao" class="com.baobaotao.anno.UserDao"/>
   <bean  id="logonService" class="com.baobaotao.anno.LogonService">
       <property name="logDao" ref="logDao"></property>
       



                

        

    

  


        

            

                    
                      最低0.47元/天 解锁文章
                        
                    
            

        


    



                



	

		

			

				
					
【Java】 java 静态注入类

				
			

			

				

					wjianwei666的专栏
				

				

					01-08
					
					1417
					
				

			

		

		

			
				
通过上述示例，我们可以看到，静态注入类是一种简单且有效的管理类之间依赖关系的方式。它通过将依赖关系注入到类的静态成员中，实现了依赖对象的共享和复用。然而，静态注入类也存在一些局限性，例如无法在运行时动态切换依赖对象、多线程环境下的同步问题等。因此，在使用静态注入类时，我们需要根据具体情况权衡利弊，并确保正确使用。关系图下面是示例代码中类之间的关系图：erDiagram。

			
		

	



                

            
              



	

		

			

				
					
【Java】java静态对象注入 静态类注入bean

				
			

			

				

					wjianwei666的专栏
				

				

					01-08
					
					784
					
				

			

		

		

			
				
静态变量/类变量不是对象的属性,而是一个类的属性,spring则是基于对象层面上的依赖注入。但是自己比较喜欢封装工具类，并通过@Component注解成功能组件，但是功能组件中的方法一般都是静态方法，静态方法只能调用静态成员变量，于是就有了下面的问题。在Spring官方文档中描述，在初始化Spring bean时，如果检测到某个bean实现了这两个接口中的一个，那么就会自动调用该豆所实现的接口方法。可以看到，无论是在静态方法中，还是在手动新的实例中，我们都成功获取了的的的的IoC容器所管理的豆。

			
		

	



              


  
              

                


	

		

			

				
					
Java 在静态方法中引入bean

				
			

			

				

					huang_1228的博客
				

				

					04-30
					
					1197
					
				

			

		

		

			
				
ApplicationContextAware: 相当于在ApplicationContext上下文初始化的时候，会触发的一个钩子，而要想触发就要加入到Bean容器中去进行管理。而后只需要在使用的时候使用bean方法，依据类型或者名称等等进行注入即可。

			
		

	





	

		

			

				
					
static方法使用bean的方式

				
			

			

				

					博观而约取 厚积而薄发
				

				

					03-28
					
					231
					
				

			

		

		

			
				
【代码】static方法使用bean的方式。

			
		

	



		

			
		



	

		

			

				
					
注入静态bean

				
			

			

				

					0老船长0的博客
				

				

					12-15
					
					926
					
				

			

		

		

			
				
spring boot 静态方法中想要使用注入的bean时，想当然的添加修饰符static，来修饰变量。
如下：
@Resource
private static  RedisTemplate&lt;String, Object&gt; redis;
然而事实证明：并不可取。无法注入，注入结果为null。
应该采用以下方式：
1、将目前所在的类用@Component、@service、@contr...

			
		

	





	

		

			

				
					
static方法中注入springBean对象

				
			

			

				

					有问题请发邮箱dengyifanlittle@163.com进行讨论
				

				

					11-02
					
					4181
					
				

			

		

		

			
				
spring启动的时候，在进行元数据管理的时候，会自动忽略掉static成员，包括其中的属性和方法。如果我们在static中需要调用spring管理的对象，此时可以使用以下三种方式进行注入。三、实现SmartInitializingSingleton。一、使用@PostConstruct注解。

			
		

	





	

		

			

				
					
静态方法中注入bean

				
			

			

				

					g_l_xz的博客
				

				

					12-04
					
					1419
					
				

			

		

		

			
				
静态方法中注入bean
@Component：把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/>
元注解，可以注解其他类注解
官方：带此注解的类看为组件，当使用基于注解的配置和类路径扫描的时候，这些类就会被实例化，其他类级别的注解也可以被认定是一种特殊类型的组件，比如@Repository @Aspect。
所以@component可以注解其他类注解
@Component
//@UtilityClass
//注意:如果类上加注解@Utilit

			
		

	





	

		

			

				
					
SpringBoot在静态方法或工具类中注入Bean及配置参数

					
热门推荐

				
			

			

				

					HOKING的专栏
				

				

					05-22
					
					1万+
					
				

			

		

		

			
				
SpringBoot在静态方法或工具类中注入Bean及配置参数

			
		

	





	

		

			

				
					
spring static静态方法里面注入bean空指针解决

				
			

			

				

					01-20
				

			

		

		

			
				
推荐的做法是遵循最佳实践，如使用`@Component`和`@Autowired`来处理Bean注入，同时确保使用支持最新JDK版本的库和框架。  在处理老项目时，确保对项目结构、依赖管理和配置有充分的理解至关重要。遇到此类问题时，...

			
		

	





	

		

			

				
					
Spring boot工具类静态属性注入及多环境配置详解

				
			

			

				

					08-27
				

			

		

		

			
				
1. Spring Boot工具类静态属性注入：使用@ConfigurationProperties注解将application.yml文件中的配置信息注入到Java类中。 2. 使用@Value注解将application.yml文件中的配置信息注入到Java类的成员变量中。 3. ...

			
		

	





	

		

			

				
					
autowired 静态方法使用_静态方法中直接使用注入的bean对象

				
			

			

				

					weixin_39980082的博客
				

				

					01-26
					
					750
					
				

			

		

		

			
				
问题：静态方法中注入bean分析问题：先看一段代码@Componentpublic class ScriptExecuteContent {@Autowiredprivate static SignRepository signRepository;public static String checkSign(String certNo, String acctNo, String instCod...

			
		

	





	

		

			

				
					
静态方法中注入bean对象

				
			

			

				

					weixin_48284907的博客
				

				

					03-16
					
					564
					
				

			

		

		

			
				
注意:别忘记写@Component注解
@Component
public class StructUtil {
    private static StructService structService;
    private static List<StructInfo> structInfos;
     
    // 通过重写set注入
    @Autowired
    public void setStructService(StructService structServi

			
		

	





	

		

			

				
					
使用Spring注解，在静态方法中注入bean

				
			

			

				

					那些年，那些醉
				

				

					04-19
					
					1万+
					
				

			

		

		

			
				
使用Spring注解，在静态方法中注入bean

			
		

	





	

		

			

				
					
静态方法注入bean

				
			

			

				

					feichen2016的博客
				

				

					05-13
					
					614
					
				

			

		

		

			
				
@Component
public class GroupNameUtil {

    private static EasemobUserGroupRepository userGrouprepository;


    @Autowired
    private EasemobUserGroupRepository easemobUserGroupRepository;


			
		

	





	

		

			

				
					
java类注入_[java]静态类中使用注入

				
			

			

				

					weixin_31109967的博客
				

				

					02-23
					
					2357
					
				

			

		

		

			
				
场景：在一个java类中，需要使用某个service，但是这个类不是单例，并且无法直接取得spring中的bean，这时就会把这个service放入静态工具类中注：静态类中是无法直接注入对象的，要采用间接的方式/** workFilesService是我们要使用的service*  @PostConstruct  @Autowired  @Component这三个注解是重要组成*/@Lazy(fa...

			
		

	





	

		

			

				
					
Spring静态注入bean的四种方式

				
			

			

				

					攻城狮不是猫
				

				

					08-23
					
					1万+
					
				

			

		

		

			
				
欢迎转载：攻城狮不是猫 

Spring静态注入的四种方式：

(说明：MongoFileOperationUtil是自己封装的一个Mongodb文件读写工具类，里面需要依赖AdvancedDatastore对象实例，dsForRW用来获取Mongodb数据源)

在springframework里，我们不能@Autowired一个静态变量,使之成为一个spring bean，例如下面这种方式：
...

			
		

	





	

		

			

				
					
静态工具类中注入Bean及引用Nacos配置

				
			

			

				

					m0_72167535的博客
				

				

					11-21
					
					1926
					
				

			

		

		

			
				
在代码开发中，经常会存在调用第三方工具或者其他系统的场景，通常封装成一个工具类供service进行调用，便于后期的维护及代码复用。工具类中的属性及方法都被static修饰，在工具类中不能使用和service中一样的注入Bean及引用Nacos值的方式。这是因为初始化类的加载升序导致的，程序启动时会加载根路径下所有的类，不管这个类是否会用到都会去加载；通过setter方法进行注入，在setter方法上添加nacos注解，获取配置的值，将值设置到静态变量中。②Nacos中配置的注入方式。①bean的注入方式。

			
		

	





	

		

			

				
					
SpringBoot在静态方法中使用注入Bean

				
			

			

				

					徐光耀的博客
				

				

					04-23
					
					1万+
					
				

			

		

		

			
				
第一种方式

给当前的类加上@Component
	声明一个静态的属性（加上注解@Autowired），一个非静态的属性。
	声明一个返回值为void并且不能抛出异常的方法，在其中将非静态属性赋值给静态属性。该方法上加上注解@PostConstruct






第二种方式

在springboot的启动类中，定义static变量ApplicationContext，利用容器的getBean方...

			
		

	





	

		

			

				
					
工具类，静态方法注入bean

				
			

			

				

					迷茫，是因为才华配不上梦想...
				

				

					06-16
					
					540
					
				

			

		

		

			
				
package com.manager.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.st.

			
		

	





	

		

			

				
					
spring静态方法 注入bean

					
最新发布

				
			

			

				

					05-08
				

			

		

		

			
				
<think>好的，我现在需要回答用户的问题：如何在Spring框架中将Bean注入到静态方法中。首先，我得回忆一下Spring的依赖注入机制，通常Spring是通过容器管理Bean的生命周期和依赖关系的，但静态方法属于类级别，而Spring默认是基于实例的依赖注入，所以这里可能需要特殊处理。

用户提到了静态方法注入Bean，我需要查阅相关的Spring文档或者常见做法。根据之前提供的引用内容，比如引用[1]提到静态工厂方法创建Bean，引用[2]和[5]讨论了在静态属性中获取Bean的方法，还有使用工具类或者非静态setter方法设置静态字段。这些都是可能的解决方案。

首先，我需要明确静态方法不能直接使用@Autowired注解，因为Spring无法直接注入静态变量。所以必须通过间接的方式。根据引用[5]，方法一是通过非静态的setter方法注入到静态变量中，比如在非静态方法上使用@Autowired，然后在方法中将实例赋值给静态变量。这种方法可行，但需要确保Spring能调用到这个setter方法。

第二种方法是使用@PostConstruct，在Bean初始化完成后，通过一个非静态的方法来初始化静态变量。这可能需要在类加载后执行某些操作，确保Spring上下文已经准备好。

第三种方法是使用ApplicationContextAware接口，创建一个工具类获取ApplicationContext，然后通过上下文获取Bean。引用[2]和[4]提到了这种方式，通过实现ApplicationContextAware，保存上下文到静态变量中，然后提供静态方法获取Bean。

另外，引用[3]展示了在定时任务中调用静态方法，可能结合Spring的调度功能，但这不是直接注入，而是通过任务触发调用工具类获取Bean。

还需要考虑线程安全和上下文加载时机的问题，确保在调用静态方法时ApplicationContext已经初始化完成。比如，工具类需要在Spring容器启动后才会被正确初始化，否则可能导致空指针异常。

总结下来，常见的实现方式包括：使用ApplicationContextAware工具类、通过setter方法间接注入静态变量、使用@PostConstruct注解初始化静态变量。需要逐一解释这些方法的步骤和注意事项，确保用户能够理解并正确实施。

最后，验证这些方法是否符合Spring的最佳实践，是否存在潜在的问题，比如内存泄漏或上下文未正确加载的情况。例如，ApplicationContextAware的方式可能会导致工具类与Spring框架紧耦合，但在某些情况下是必要的。</think>### Spring框架中静态方法注入Bean的实现方式

在Spring框架中，由于依赖注入（DI）是基于对象实例的，直接通过`@Autowired`注入静态变量或静态方法是不可行的[^5]。以下是五种常见的实现方式，均参考了Spring的扩展机制和设计模式：

---

#### 方式1：通过工具类获取ApplicationContext（推荐）
1. **创建工具类**：实现`ApplicationContextAware`接口，将上下文保存到静态变量。
```java
@Component
public class SpringBeanUtil implements ApplicationContextAware {
    private static ApplicationContext context;
    
    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        context = ctx;
    }
    
    public static <T> T getBean(Class<T> beanClass) {
        return context.getBean(beanClass);
    }
}
```
2. **在静态方法中调用**：
```java
public class StaticClass {
    public static void execute() {
        UserService service = SpringBeanUtil.getBean(UserService.class);
        service.doSomething();
    }
}
```
*优点*：代码简洁，适用于全局调用[^2][^4]。  
*注意*：需确保工具类已被Spring管理（添加`@Component`）。

---

#### 方式2：通过非静态Setter方法注入静态变量
在非静态方法中通过`@Autowired`赋值给静态变量：
```java
@Component
public class StaticHolder {
    private static UserService userService;
    
    @Autowired
    public void setUserService(UserService service) {
        StaticHolder.userService = service;
    }
}
```
*原理*：Spring实例化`StaticHolder`时会调用`setUserService`，将实例赋值给静态变量[^5]。

---

#### 方式3：使用@PostConstruct初始化静态变量
结合`@Autowired`和`@PostConstruct`注解：
```java
@Component
public class StaticInitializer {
    @Autowired
    private UserService instanceService;
    private static UserService staticService;
    
    @PostConstruct
    public void init() {
        staticService = instanceService;
    }
    
    public static void staticMethod() {
        staticService.doSomething();
    }
}
```
*说明*：`@PostConstruct`确保在Bean初始化完成后执行赋值操作[^5]。

---

#### 方式4：通过XML配置静态工厂方法
1. **定义静态工厂类**：
```java
public class ServiceFactory {
    public static UserService createUserService() {
        return new UserServiceImpl();
    }
}
```
2. **XML配置**：
```xml
<bean id="userService" class="com.example.ServiceFactory" 
      factory-method="createUserService"/>
```
*适用场景*：需要兼容传统XML配置的项目[^1]。

---

#### 方式5：结合@Configuration静态加载
在配置类中显式注入：
```java
@Configuration
public class StaticConfig {
    private static UserService userService;
    
    @Autowired
    public StaticConfig(UserService service) {
        StaticConfig.userService = service;
    }
}
```
*注意*：需确保配置类优先加载，避免静态方法调用时变量未初始化。

---

### 关键问题与解决方案
| 问题类型               | 解决方案                          |
|------------------------|-----------------------------------|
| 上下文未初始化         | 使用`@DependsOn`指定依赖顺序      |
| 多线程环境下的线程安全 | 结合`@Scope("prototype")`或锁机制 |
| 工具类与框架耦合       | 通过接口隔离，避免直接依赖具体类  |

---

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值