本文由 简悦 SimpRead 转码， 原文地址 blog.csdn.net
介绍 Spring Boot 启动时，自动执行指定方法的 7 种方法
前言
在实际项目开发过程中，我们有时候需要让项目在启动时执行特定方法。如要实现这些功能：
提前加载相应的数据到缓存中；
检查当前项目运行环境；
检查程序授权信息，若未授权则不能使用后续功能；
执行某个特定方法；
实现方式
那么实现提前加载的方式有哪些呢？接下来我为大家介绍七种实现方式，按照执行顺序进行介绍。
1. 实现 ServletContextListener 接口 contextInitialized 方法
代码如下（示例）：
1 import lombok.extern.slf4j.Slf4j;
2 import org.springframework.stereotype.Component;
4 import javax.servlet.ServletContextEvent;
5 import javax.servlet.ServletContextListener;
7 @Slf4j
8 @Component
9 public class ServletContextListenerImpl implements ServletContextListener {
10 /**
11 * 静态代码块会在依赖注入后自动执行,并优先执行
12 */
13 static{
14 log.info("启动时自动执行 静态代码块");
15 }
16 /**
17 * 在初始化Web应用程序中的任何过滤器或Servlet之前，将通知所有ServletContextListener上下文初始化。
18 */
19 @Override
20 public void contextInitialized(ServletContextEvent sce) {
21 log.info("启动时自动执行 ServletContextListener 的 contextInitialized 方法");
22 }
23 }
注意：该方法会在填充完普通 Bean 的属性，但是还没有进行 Bean 的初始化之前执行
2. 静态代码块方式
将要执行的方法所在的类交个 Spring 容器扫描 (@Component)，在类中添加静态代码块，这样在 Spring 在扫描这类时候就会自动执行静态代码，达到代码自动运行的效果。示例见👆。
3.@PostConstruct 注解方式
将要执行的方法所在的类交个 Spring 容器扫描 (@Component), 并且在要执行的方法上添加 @PostConstruct 注解执行
代码如下（示例）：
1 import lombok.extern.slf4j.Slf4j;
2 import org.springframework.stereotype.Component;
4 import javax.annotation.PostConstruct;
6 @Slf4j
7 @Component
8 public class PostConstructTest {
9 @PostConstruct
10 public void postConstruct() {
11 log.info("启动时自动执行 @PostConstruct 注解方法");
12 }
13 }
4. 实现 ServletContextAware 接口 setServletContext 方法
代码如下（示例）：
1 import lombok.extern.slf4j.Slf4j;
2 import org.springframework.stereotype.Component;
3 import org.springframework.web.context.ServletContextAware;
5 import javax.servlet.ServletContext;
7 @Slf4j
8 @Component
9 public class ServletContextAwareImpl implements ServletContextAware {
10 /**
11 * 在填充普通bean属性之后但在初始化之前调用
12 * 类似于InitializingBean's 的 afterPropertiesSet 或自定义init方法的回调
13 */
14 @Override
15 public void setServletContext(ServletContext servletContext) {
16 log.info("启动时自动执行 ServletContextAware 的 setServletContext 方法");
17 }
18 }
5. @EventListener 方式
将要执行的方法所在的类交个 Spring 容器扫描 (@Component), 并且在要执行的方法上添加 @EventListener 注解执行
代码如下（示例）：
1 import lombok.extern.slf4j.Slf4j;
2 import org.springframework.context.event.ContextRefreshedEvent;
3 import org.springframework.context.event.EventListener;
4 import org.springframework.stereotype.Component;
6 @Slf4j
7 @Component
8 public class EventListenerTest {
9 @EventListener
10 public void onApplicationEvent(ContextRefreshedEvent event) {
11 log.info("启动时自动执行 @EventListener 注解方法");
12 }
13 }
6. 实现 ApplicationRunner 接口 run 方法
代码如下（示例）：
1 import lombok.extern.slf4j.Slf4j;
2 import org.springframework.boot.ApplicationArguments;
3 import org.springframework.boot.ApplicationRunner;
4 import org.springframework.stereotype.Component;
6 import java.util.Set;
8 @Slf4j
9 @Component
10 public class ApplicationRunnerImpl implements ApplicationRunner {
11 /**
12 * 用于指示bean包含在SpringApplication中时应运行的接口。可以定义多个ApplicationRunner bean
13 * 在同一应用程序上下文中，可以使用有序接口或@order注释对其进行排序。
14 */
15 @Override
16 public void run(ApplicationArguments args) throws Exception {
17 log.info("启动时自动执行 ApplicationRunner 的 run 方法");
19 Set<String> optionNames = args.getOptionNames();
20 for (String optionName : optionNames) {
21 log.info("这是传过来的参数[{}]", optionName);
22 }
23 String[] sourceArgs = args.getSourceArgs();
24 for (String sourceArg : sourceArgs) {
25 log.info("这是传过来sourceArgs[{}]", sourceArg);
26 }
27 }
28 }
7. 实现 CommandLineRunner 接口 run 方法
代码如下（示例）：
1 import lombok.extern.slf4j.Slf4j;
2 import org.springframework.boot.CommandLineRunner;
3 import org.springframework.stereotype.Component;
5 @Slf4j
6 @Component
7 public class CommandLineRunnerImpl implements CommandLineRunner {
9 @Override
10 public void run(String... args) throws Exception {
11 log.info("启动时自动执行 CommandLineRunner 的 run 方法");
12 }
13 }
以上几种方式的执行顺序
以上几种方式的执行顺序如下图所示：
附：
ServletContextListener 使用详解
在 Servlet API 中有一个 ServletContextListener 接口，它能够监听 ServletContext 对象的生命周期，实际上就是监听 Web 应用的生命周期。
当 Servlet 容器启动或终止 Web 应用时，会触发 ServletContextEvent 事件，该事件由 ServletContextListener 来处理。在 ServletContextListener 接口中定义了处理 ServletContextEvent 事件的两个方法。
l contextInitialized(ServletContextEvent sce) ：当 Servlet 容器启动 Web 应用时调用该方法。在调用完该方法之后，容器再对 Filter 初始化，并且对那些在 Web 应用启动时就需要被初始化的 Servlet 进行初始化。
l contextDestroyed(ServletContextEvent sce) ：当 Servlet 容器终止 Web 应用时调用该方法。在调用该方法之前，容器会先销毁所有的 Servlet 和 Filter 过滤器。
下面通过两个具体的例子来介绍 ServletContextListener 的用法。
例一：在服务启动时，将数据库中的数据加载进内存，并将其赋值给一个属性名，其它的 Servlet 就可以通过 getAttribute 进行属性值的访问。有如下两个步骤：
1.ServletContext 对象是一个为整个 web 应用提供共享的内存，任何请求都可以访问里面的内容
- 如何实现在服务启动的时候就动态的加入到里面的内容：我们需要做的有：
- 1 ） 实现 servletContextListerner 接口 并将要共享的通过 setAttribute （ name,data ）方法提交到内存中去 ；
- 2 ）应用项目通过 getAttribute(name) 将数据取到 。
package ServletContextTest;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import util.ConnectTool;
public class ServletContextLTest implements ServletContextListener{
// 实现其中的销毁函数
public void contextDestroyed(ServletContextEvent sce) {
System.out.println("this is last destroyeed");
}
// 实现其中的初始化函数，当有事件发生时即触发
public void contextInitialized(ServletContextEvent sce) {
ServletContext sct=sce.getServletContext();
Map<Integer,String> depts=new HashMap<Integer,String>();
Connection connection=null;
PreparedStatement pstm=null;
ResultSet rs=null;
try{
connection=ConnectTool.getConnection();
String sql="select deptNo,dname from dept";
pstm=connection.prepareStatement(sql);
rs=pstm.executeQuery();
while(rs.next()){
depts.put(rs.getInt(1), rs.getString(2));
}
// 将所取到的值存放到一个属性键值对中
sct.setAttribute("dept", depts);
System.out.println("======listener test is beginning=========");
}catch(Exception e){
e.printStackTrace();
}finally{
ConnectTool.releasersc(rs, pstm, connection);
}
}
}
在完成上述编码后，仍需在 web.xml 中进行如下配置，以使得该监听器可以起作用。
<listener>
<listener-class>ServletContextTest.ServletContextLTest</listener-class>
</listener>
在完成上述配置后， web 服务器在启动时，会直接加载该监听器，通过以下的应用程序就可以进行数据的访问。
package ServletContextTest;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class CreateEmployee extends HttpServlet{
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
ServletContext sct=getServletConfig().getServletContext();
// 从上下文环境中通过属性名获取属性值
Map<Integer,String> dept=(Map<Integer,String>)sct.getAttribute("dept");
Set<Integer> key=dept.keySet();
response.setContentType("text/html;charset=utf-8");
PrintWriter out=response.getWriter();
out.println("<html>");
out.println("<body>");
out.println("<form action='/register' action='post'>");
out.println("<table alignb='center'>");
out.println("<tr>");
out.println("<td>");
out.println("username:");
out.println("</td>");
out.println("<td>");
out.println("<input type='text' );
out.println("</tr>");
out.println("<tr>");
out.println("<td>");
out.println("city:");
out.println("</td>");
out.println("<td>");
out.println("<select );
for(Integer i:key){
out.println("<option value='"+i+"'>"+dept.get(i)+"</option>");
}
out.println("</select>");
out.println("</td>");
out.println("<tr>");
out.println("</table>");
out.println("</form>");
out.println("</body>");
out.println("</html>");
}
