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

其他 2019-03-18 17:11:22 阅读次数: 0
 
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) {

    }
}

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));
    }
}

关于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();
    }
}

在百度的过程中，突然看见一博客， 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();
    }
}

至此，我是不想再想了。
在这里感谢下面的几篇博客：
自启动监听类（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

猜你喜欢

转载自www.cnblogs.com/threadj/p/10553238.html
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022