Spring执行顺序与ApplicationContext

一、spring容器初始化bean对象的顺序是listener–>filter–>servlet，其中

stattic>构造方法 > @Autowired > @PostConstruct。

故在static方法里面调用某个Bean，不可以用Autowired ，可以让通过ApplicationContext获取Bean。

二、如果在servlet初始化之前使用注解获取bean，是获取不到的，因为还没有注入进去。这时候我们可以通过以下几种方法来获取ApplicationContext

1、方法一：

package com.demo.util;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
 
/**
 * 获得整个工程的上下文环境
 *
 */
public final class SpringContextUtil {
    /**
     * 上下文
     */
    private static ApplicationContext ctu;
 
    /**
     * 私有构造函数
     */
    private SpringContextUtil() {
        super();
    }
 
    public static void setApplicationContext(ApplicationContext applicationContext){
        ctu = applicationContext;
    }
 
    /**
     * 获得上下文
     *
     * @return ApplicationContext
     */
    public static ApplicationContext getApplicationContext() {
        return ctu;
    }
 
}

public classUser{
 
  private static Userservice userService;
	
  private static RoleService roleService;
	
	static{
		userService= (Userservice ) SpringContextUtil.getApplicationContext().getBean("userService");
		roleService= (RoleService ) SpringContextUtil.getApplicationContext().getBean("roleService");
	}
 
	
	public staic void addUser(User user,Role role)
			userService.insert(user);
	}
}

@Override方法也会在@ Autowired之前执行，这样使用到的@Autowired加载的bean会为null，故也需要像上面那样，如：

public class ExecuteAddJob implements org.quartz.Job{
	
    private static JobService jobService;
	
	private static JobSchedule jobSchedule;
	
	static{
		jobService = (JobService) SpringContextUtil.getApplicationContext().getBean("jobService");
		jobSchedule = (JobSchedule) SpringContextUtil.getApplicationContext().getBean("jobSchedule");
	}
 
	@Override
	public void execute(JobExecutionContext context)
			throws JobExecutionException {
		//获取未执行过的job
		List<Job> jobList = jobService.getUnExecutedJobs();
        if (CollectionUtils.isNotEmpty(jobList)) {
            for (Job job : jobList) {
                try {
                	
					jobSchedule.addJob(job);
					//添加到schedule后，状态更新为已执行
					job.setState(JobStatus.EXECUTE.getStatus());
					jobService.updateJob(job);
				} catch (SchedulerException e) {
					
					e.printStackTrace();
				}
            }
        }
	}
 
}

启动类：

package com.demo;
 
import com.demo.util.SpringContextUtil;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
 
@SpringBootApplication
public class SecurityApplication {
 
    public static void main(String args[]){
        ApplicationContext applicationContext = SpringApplication.run(SecurityApplication.class, args);
        //实例化上下文对象
        SpringContextUtil.setApplicationContext(applicationContext);
  }
}

如果是在filter过滤器中获取spring的bean：

Bean都是被Spring容器管理的，使用的时候，直接通过注解@Autowired，注入即可

在Filter中，不能使用@Autowired注解注入，通过注解获取到的为null
Filter并没有被Spring容器管理，它是运行在Tomcat上的，是由Servlet来管理的

ServletContext sc = req.getSession().getServletContext();
        XmlWebApplicationContext cxt = (XmlWebApplicationContext) WebApplicationContextUtils.findWebApplicationContext(sc);
        redisClient = (RedisClient) cxt.getBean("redisClient");

2、方法二：

package com.demo.factory;
 
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
 
 
@Component
public class ApplicationContextRegister implements ApplicationContextAware {
    private static Logger logger = LoggerFactory.getLogger(ApplicationContextRegister.class);
    private static ApplicationContext APPLICATION_CONTEXT;
    /**
     * 设置spring上下文
     * @param applicationContext spring上下文
     * @throws BeansException
     * */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        logger.debug("ApplicationContext registed-->{}", applicationContext);
        DefaultBeanFactory.setSpringApplicationContext(applicationContext);
        APPLICATION_CONTEXT = applicationContext;
    }
 
    /**
     * 获取容器
     * @return
     */
    public static ApplicationContext getApplicationContext() {
        return APPLICATION_CONTEXT;
    }
 
    /**
     * 获取容器对象
     * @param type
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> type) {
        return APPLICATION_CONTEXT.getBean(type);
    }
}

package com.demo.factory;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 
public class DefaultBeanFactory {
	private static ApplicationContext context = null;
	private static DefaultBeanFactory instance = null;
	private static Object lock = new Object();
 
	private DefaultBeanFactory(String filepath){
		try {
			context = new ClassPathXmlApplicationContext(filepath);
		} catch (Exception e) {
		}
	}
	@SuppressWarnings("static-access")
	private DefaultBeanFactory(ApplicationContext context){
		try {
			this.context = context;
		} catch (Exception e) {
		}
	}
 
	public static void setSpringApplicationContext(ApplicationContext context){
		synchronized (lock) {
			instance = new DefaultBeanFactory(context);
		}
	}
	public static DefaultBeanFactory getInstance() {
		if(instance == null || context == null){
			throw new RuntimeException("Spring context is null!");
		}
		return instance;
	}
 
	public static DefaultBeanFactory getInstance(String filepath) {
		synchronized (lock) {
			instance = new DefaultBeanFactory(filepath);
		}
		return instance;
	}
	public Object getBean(String name) {
		return context.getBean(name);
	}
}

bean获取类：

package com.demo.factory;
 
import com.demo.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
 
public class ServiceFactory {
 
 
    private static Logger logger = LoggerFactory.getLogger(ServiceFactory.class);
 
    private static ServiceFactory instance = new ServiceFactory();
 
    private final String USER_SERVICE_BEAN="userService";
 
 
 
 
    public ServiceFactory() {
        // TODO Auto-generated constructor stub
    }
 
    public static ServiceFactory getInstance() {
        if (instance == null) {
            instance = new ServiceFactory();
        }
        return instance;
    }
 
    public UserService createUserService() {
        try {
            return (UserService) DefaultBeanFactory.getInstance().getBean(USER_SERVICE_BEAN);
        } catch (Exception e) {
            throw new RuntimeException("创建 USER_SERVICE BEAN 异常", e);
        }
    }
 
 
}

启动类不需要做修改：

@SpringBootApplication
@MapperScan("com.demo.dao")
public class JobStart {
    public static void main(String[] args) {
        SpringApplication.run(JobStart.class, args);
    }
}

应用：

package com.demo.job;
import com.demo.dao.UserDao;
import com.demo.dto.User;
import com.demo.factory.ServiceFactory;
import com.demo.service.UserService;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
 
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class MyDbJob implements Job{
    private static UserService userService;
    static {
        userService = ServiceFactory.getInstance().createUserService();
    }
 
    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        System.out.print("执行db");
        User user = new User();
        user.setName("名称");
        user.setAge(18);
        userService.insert(user);
    }
 
}

3、方法三：

以上方法在BasicHttpAuthenticationFilter中获取不到bean，

以下方法测试可用：

ServletContext servletContext = request.getServletContext();
        ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        redisClient = (RedisClient) context.getBean("redisClient");

应用：

package com.shiro.jwt.handler;
 
import com.shiro.jwt.dto.CommonConstant;
import com.shiro.jwt.dto.JwtToken;
import com.shiro.jwt.util.RedisClient;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.util.AntPathMatcher;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.support.WebApplicationContextUtils;
 
import javax.servlet.ServletContext;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class JwtFilter extends BasicHttpAuthenticationFilter {
 
    private static RedisClient redisClient;
    private AntPathMatcher antPathMatcher =new AntPathMatcher();
   /* static {
           //获取不到bean，报错spring context is null
        redisClient = ServiceFactory.getInstance().createRedisClient();
    }*/
    /**
     * 执行登录认证(判断请求头是否带上token)
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        System.out.println("JwtFilter-->>>isAccessAllowed-Method:init()");
        //如果请求头不存在token,则可能是执行登陆操作或是游客状态访问,直接返回true
        if (isLoginAttempt(request, response)) {
            return true;
        }
        //如果存在,则进入executeLogin方法执行登入,检查token 是否正确
        try {
            executeLogin(request, response);return true;
        } catch (Exception e) {
            throw new AuthenticationException("Token失效请重新登录");
        }
    }
 

    /**
     * 判断用户是否是登入,检测headers里是否包含token字段
     */
    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        ServletContext servletContext = request.getServletContext();
        ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        redisClient = (RedisClient) context.getBean("redisClient");
 
        System.out.println("JwtFilter-->>>isLoginAttempt-Method:init()");
        HttpServletRequest req = (HttpServletRequest) request;
        if(antPathMatcher.match("/login",req.getRequestURI())){
            return true;
        }
        String token = req.getHeader(CommonConstant.ACCESS_TOKEN);
        if (token == null) {
            return false;
        }
        Object o = redisClient.get(CommonConstant.PREFIX_USER_TOKEN,token);
        if(ObjectUtils.isEmpty(o)){
            return false;
        }
        System.out.println("JwtFilter-->>>isLoginAttempt-Method:返回true");
        return true;
    }
 
    /**
     * 重写AuthenticatingFilter的executeLogin方法丶执行登陆操作
     */
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        System.out.println("JwtFilter-->>>executeLogin-Method:init()");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader(CommonConstant.ACCESS_TOKEN);//Access-Token
        JwtToken jwtToken = new JwtToken(token);
        // 提交给realm进行登入,如果错误他会抛出异常并被捕获, 反之则代表登入成功,返回true
        getSubject(request, response).login(jwtToken);return true;
    }
 
    /**
     * 对跨域提供支持
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        System.out.println("JwtFilter-->>>preHandle-Method:init()");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        // 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }
}