SpringBoot集成Socket服务后打包(war包)启动时如何启动Socket服务(web应用外部tomcat启动)

时间:2022-08-30 06:26:32
 
1、首先知道SpringBoot打包为jar和war包是不一样的(只讨论SpringBoot环境下web应用打包)
    1.1、jar和war包的打开方式不一样,虽然都依赖java环境,但是jar包只需要外部提供java环境,war需要外部提供java和servlet环境
    1.2、jar包和war包的启动流程不一样:
            ①、jar包的启动时直接由项目的主函数开始启动,此时会先初始化IOC容器,然后才会进行内置Servlet环境(一般为Tomcat)的启动。
//jar包启动入口
@SpringBootApplication
public class HelloWorldApplcation { public static void main(String[] args) {
SpringApplication.run(HelloWorldApplcation.class, args);
} }

②、war包通常使用Tomcat进行部署启动,在tomcat启动war应用时,会先进行Servlet环境的初始化,之后才会进行到IOC容器的初始化,也就是说,在servlet初始化过程中是不能使用IOC依赖注入的。

public class ServletInitializer extends SpringBootServletInitializer {

    @Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { return application.sources(HelloWorldApplcation.class);
} }
2、实现在springboot应用启动的时候启动Socket服务
    2.1、jar包情况下,将Socket服务交由IOC容器进行管理,然后在IOC容器创建完成后,获取到已经初始化的Socket服务实例,然后开始Socket服务。在这样的情况下,可以在Socket服务类上进行依赖注入,也就是说可以使用@Autowired
@SpringBootApplication
public class HelloWorldApplcation { public static void main(String[] args) {
ApplicationContext applicationContext = SpringApplication.run(HelloWorldApplcation.class, args);
SocketServer socketServer =applicationContext.getBean(SocketServer.class);
socketServer.start();
} }

2.2、war包情况下,由于是先进行Servlet环境的初始化,然后再进行IOC容器的创建,有了这个先后顺序,即知道,是不可能在Servlet创建时拿到WebApplicationContext对象的,下面是我的验证

package com.geniuses.sewage_zero_straight.listener;

import com.geniuses.sewage_zero_straight.net.socket.SocketServer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils; import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener; @Slf4j
@WebListener
public class SocketListener implements ServletContextListener { @Autowired
private SocketServer socketServer; @Override
public void contextInitialized(ServletContextEvent sce) { log.info("准备启动Socket服务...");
log.info("SocketServer:{}", socketServer);
socketServer.start();
} @Override
public void contextDestroyed(ServletContextEvent sce) { }
}

SpringBoot集成Socket服务后打包(war包)启动时如何启动Socket服务(web应用外部tomcat启动)

package com.geniuses.sewage_zero_straight.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils; import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.HandlesTypes; @Slf4j
@HandlesTypes({WebApplicationInitializer.class})
public class SocketConfig implements WebApplicationInitializer { @Override
public void onStartup(ServletContext servletContext) throws ServletException {
WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
log.info("application: {}", webApplicationContext);
//log.info("SocketServer: {}", webApplicationContext.getBean(SocketServer.class));
}
}

SpringBoot集成Socket服务后打包(war包)启动时如何启动Socket服务(web应用外部tomcat启动)

关于WebApplicationInitializer理解,参见:https://blog.csdn.net/zq17865815296/article/details/79464403
以上是为测试Servlet环境中能否拿到IOC容器和能否注入Bean,发现并不能拿到对象
 
我就开始想啊,要怎么才能拿到IOC容器对象嘞,随后发现SpringBootServletInitializer便是创建IOC容器的起始点
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
// package org.springframework.boot.web.servlet.support; import java.util.Collections;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.builder.ParentContextApplicationContextInitializer;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent;
import org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.util.Assert;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.ConfigurableWebEnvironment;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.WebApplicationContext; public abstract class SpringBootServletInitializer implements WebApplicationInitializer {
protected Log logger;
private boolean registerErrorPageFilter = true; public SpringBootServletInitializer() {
} protected final void setRegisterErrorPageFilter(boolean registerErrorPageFilter) {
this.registerErrorPageFilter = registerErrorPageFilter;
} public void onStartup(ServletContext servletContext) throws ServletException {
this.logger = LogFactory.getLog(this.getClass());
//这里开始创建IOC容器
WebApplicationContext rootAppContext = this.createRootApplicationContext(servletContext);
if (rootAppContext != null) {
servletContext.addListener(new ContextLoaderListener(rootAppContext) {
public void contextInitialized(ServletContextEvent event) {
}
});
} else {
this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not return an application context");
} } //IOC容器创建方法
protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
SpringApplicationBuilder builder = this.createSpringApplicationBuilder();
builder.main(this.getClass());
ApplicationContext parent = this.getExistingRootWebApplicationContext(servletContext);
if (parent != null) {
this.logger.info("Root context already created (using as parent).");
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, (Object)null);
builder.initializers(new ApplicationContextInitializer[]{new ParentContextApplicationContextInitializer(parent)});
} builder.initializers(new ApplicationContextInitializer[]{new ServletContextApplicationContextInitializer(servletContext)});
builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);
builder = this.configure(builder);
builder.listeners(new ApplicationListener[]{new SpringBootServletInitializer.WebEnvironmentPropertySourceInitializer(servletContext)});
SpringApplication application = builder.build();
if (application.getAllSources().isEmpty() && AnnotationUtils.findAnnotation(this.getClass(), Configuration.class) != null) {
application.addPrimarySources(Collections.singleton(this.getClass()));
} Assert.state(!application.getAllSources().isEmpty(), "No SpringApplication sources have been defined. Either override the configure method or add an @Configuration annotation");
if (this.registerErrorPageFilter) {
application.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
}
return this.run(application);
} protected WebApplicationContext run(SpringApplication application) {
return (WebApplicationContext)application.run(new String[0]);
} }
}

这个时候我想到,如果不将SocketServer交由IOC进行管理,那么可以在实现的WebApplicationInitializer自定义类中启动SocketServer

package com.geniuses.sewage_zero_straight.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils; import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.HandlesTypes; /**
*
*/
@Slf4j
@HandlesTypes({WebApplicationInitializer.class})
public class SocketConfig implements WebApplicationInitializer { @Override
public void onStartup(ServletContext servletContext) throws ServletException {
new Thread(new SocketRunnable(new SocketServer())).start();
}
}

这里为什么要用一个新的线程来启动Socket服务,因为SocketServer服务端的实现中,使用while循环进行等待客户端socket进行连接,启动时便开始等待(阻塞),如果不使用一个新的线程启动,那么整个war应用服务启动线程便会在此处阻塞。这样虽然可以解决Socket服务随着应用启动而启动,但是又出现了一个新的问题,那就是SocketServer无法使用@Autowired了,因为SocketServer没有被IOC进行管理,无法进行依赖的注入。如果你不需要依赖,那么此法可行。

然后我又开始思考了,如果我需要进行依赖注入,由IOC进行SocketServer的管理,那么我要怎么样才能获取到WebApplicationContext对象,然后再通过该对象拿到SocketServer实例,然后再启动Socket服务。如果我继承了SpringBootServletInitializer,并重写onStartup方法,再重写的onStartup方法中进行Socket服务的启动会怎么样,最后发现Socket服务启动了,但是进行了两次onStartup方法的调用,第一次是自定义的SpringBootServletInitializer的实现类,第二次便是SpringBootServletInitializer类。即便只会启动一次,这样的代码也具有着极强的侵入性,便放弃了。

@Override
public void onStartup(ServletContext servletContext) throws ServletException {
this.logger = LogFactory.getLog(this.getClass());
//这里开始创建IOC容器
WebApplicationContext rootAppContext = this.createRootApplicationContext(servletContext);
//在这里进行启动Socket服务
new Thread(new SocketRunnable(rootAppContext.getBean(SocketServer.class))).start();
if (rootAppContext != null) {
servletContext.addListener(new ContextLoaderListener(rootAppContext) {
public void contextInitialized(ServletContextEvent event) {
}
});
} else {
this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not return an application context");
} }
然后我又开始思考,既然有ServletContextListener 监听ServletContext对象的创建以及销毁,那么是不是有监听IOC容器的创建和销毁嘞,随后开始进行了百度
.................................................
是的,没错,这个真的有,详情参见:https://blog.csdn.net/qq_40693828/article/details/81448934
感谢大佬
其实在这里想到了Javaweb整合spring的时候,好像有一个初始化IOC容器的监听器来着,忘了,活该自己技术差......
在这里将SocketServer注入到SocketThread中,这里还有一个疑问,在这里使用@Autowired注入SocketThread不是很稳定,猜测可能与IOC的初始化时间前后有关系,不知道是为何
package com.geniuses.sewage_zero_straight.listener;

import com.geniuses.sewage_zero_straight.net.socket.SocketServer;
import com.geniuses.sewage_zero_straight.net.socket.SocketThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils; import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.annotation.WebListener; @Slf4j
@WebListener
public class MyContextLoaderListener extends ContextLoaderListener { @Override
public void contextInitialized(ServletContextEvent event) {
ServletContext servletContext = event.getServletContext();
WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
log.info("webApplicationContext:{}",webApplicationContext);
SocketThread socketThread = webApplicationContext.getBean(SocketThread.class);
servletContext.setAttribute("SocketThread", socketThread);//在这里放进去之后......,好像也没有必要放,可以从WebApplicationContext中获取...
log.info("socketThread:{}", socketThread);
socketThread.start();
}
}

SpringBoot集成Socket服务后打包(war包)启动时如何启动Socket服务(web应用外部tomcat启动)

在百度的过程中,突然看见一博客,https://www.jianshu.com/p/90063de8cf9b,感谢这位大神

在这里由SocketThread实现InitializingBean,实现afterPropertiesSet,这样,在该类的依赖注入完毕之后,会自动调用afterPropertiesSet方法,这样便可以在这里启动socket服务。关于InitializingBean的介绍,参见上面的这个链接。

package com.geniuses.sewage_zero_straight.net.socket;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component; @Slf4j
@Component
public class SocketThread extends Thread implements InitializingBean { @Autowired
private SocketServer socketServer; @Override
public void run() {
log.info("当前线程名:{}", Thread.currentThread().getName());
log.info("由当前线程开始启动Socket服务...");
socketServer.start();
} @Override
public void afterPropertiesSet() throws Exception {
start();
}
}

SpringBoot集成Socket服务后打包(war包)启动时如何启动Socket服务(web应用外部tomcat启动)

至此,我是不想再想了。
在这里感谢下面的几篇博客:
自启动监听类(InitializingBean)介绍:https://www.jianshu.com/p/90063de8cf9b
springboot中启动流程说明:https://www.jb51.net/article/142981.htm
SpringBoot中WebApplicationInitializer的理解:https://blog.csdn.net/zq17865815296/article/details/79464403
Spring中ContextLoaderListener作用:https://blog.csdn.net/qq_40693828/article/details/81448934
 
最后说一下我的开发环境:win7_64旗舰版、jdk1.8、idea、tomcat8.5