spring 在静态工具类中使用注解注入bean

/**
* @author: jerry
* @Email:
* @Company:
* @Action: 日志处理工具类
* @DATE: 2016-9-19
*/

@Component//泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注
public class LogUtil {

@Autowired<br>//注意这里非静态
private AdminLogService logService;

private static LogUtil logUtil;

@PostConstruct //@PostConstruct修饰的方法会在服务器加载Servle的时候运行，并且只会被服务器执行一次。PostConstruct在构造函数之后执行,init()方法之前执行
public void init() {
logUtil = this;
logUtil.logService = this.logService;

}
public AdminLogService getUserService() {
return logService;
}
public void setUserService(AdminLogService userService) {
this.logService = userService;
}
public static void addLog(LoginInfo loginInfo,String desc){
//添加日志
AdminLog log=new AdminLog();
log.setCreatetime(new Date());
log.setDescription(desc);
try {
log.setCuid(loginInfo.getUser().getId());
log.setCreateuser(loginInfo.getUser().getAccount());
logUtil.logService.insertLog(log);
} catch (Exception e) {
log.setCuid(0);
log.setCreateuser("unknow");<br>//调用时通过类去调
logUtil.logService.insertLog(log);

}

}

}




1. public class LogUtil {    
2.     @Autowired    
3.     private LogService logService;    
4.     private static LogUtil logUtil;    
5.     @PostConstruct      
6.     public void init() {    
7.         logUtil = this;    
8.         logUtil.logService = this.logService;    
9.     }    
10.     //之后调用    
11.     logUtil.logService.xxx();    
12. }  

@PostConstruct
  被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行，并且只会被服务器调用一次，类似于Servlet的init()方法。

  被@PostConstruct修饰的方法会在构造函数之后，init()方法之前执行。

@PreConstruct

  被PreConstruct修饰的方法会在服务器卸载Servlet的时候运行，并且只会被服务器调用一次，类似于Servlet的destroy()方法。
  被@PreConstruct修饰的方法会在destroy()方法之后运行，在Servlet被彻底卸载以前。




或者使用spring获得bean的方式

3、通用的方法来了，神器啊，前的  1、2两种方法并不通用，可以抛弃了。
在配置文件中加入：

Xml代码

1. <!-- 用于持有ApplicationContext,可以使用SpringContextHolder.getBean('xxxx')的静态方法得到spring bean对象 -->  
2. <bean class="com.xxxxx.SpringContextHolder" lazy-init="false" />  

 

Java代码

1. import org.springframework.context.ApplicationContext;  
2. import org.springframework.context.ApplicationContextAware;  
3. /** 
4.  * 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候中取出ApplicaitonContext. 
5.  *  
6.  */  
7. public class SpringContextHolder implements ApplicationContextAware {  
8. private static ApplicationContext applicationContext;  
9.   
10. /** 
11. * 实现ApplicationContextAware接口的context注入函数, 将其存入静态变量. 
12. */  
13. public void setApplicationContext(ApplicationContext applicationContext) {  
14. SpringContextHolder.applicationContext = applicationContext; // NOSONAR  
15. }  
16.   
17. /** 
18. * 取得存储在静态变量中的ApplicationContext. 
19. */  
20. public static ApplicationContext getApplicationContext() {  
21. checkApplicationContext();  
22. return applicationContext;  
23. }  
24.   
25. /** 
26. * 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型. 
27. */  
28. @SuppressWarnings("unchecked")  
29. public static <T> T getBean(String name) {  
30. checkApplicationContext();  
31. return (T) applicationContext.getBean(name);  
32. }  
33.   
34. /** 
35. * 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型. 
36. */  
37. @SuppressWarnings("unchecked")  
38. public static <T> T getBean(Class<T> clazz) {  
39. checkApplicationContext();  
40. return (T) applicationContext.getBeansOfType(clazz);  
41. }  
42.   
43. /** 
44. * 清除applicationContext静态变量. 
45. */  
46. public static void cleanApplicationContext() {  
47. applicationContext = null;  
48. }  
49.   
50. private static void checkApplicationContext() {  
51. if (applicationContext == null) {  
52. throw new IllegalStateException("applicaitonContext未注入,请在applicationContext.xml中定义SpringContextHolder");  
53. }  
54. }  
55. }