Tomcat

关于tomcat:Tomcat-下部署若依单体应用可观测最佳实践

实现目标采集指标信息采集链路信息采集日志信息采集 RUM 信息会话重放即用户拜访前端的一系列过程的会话录制信息，包含点击某个按钮、操作界面、停留时间等，有助于客户真是用意、操作复现版本信息Tomcat (9.0.81)Springboot(2.6.2)JDK (>=8)DDTrace (>=1.0)特地阐明：如果是 Springboot 我的项目，Tomcat 大版本需与 Springboot 内置的 Tomcat 大版本统一，否则可能会存在启动异样。若依的单体利用下载源码若依的单体利用：https://gitee.com/y_project/RuoYi/tree/master git clone https://gitee.com/y_project/RuoYi.git移除外部 tomcat调整我的项目根目录的 pom.xml ...... <dependencyManagement> <dependencies>  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>2.5.15</version> <type>pom</type> <scope>import</scope>  <exclusions> <exclusion> <artifactId>spring-boot-starter-tomcat</artifactId> <groupId>org.springframework.boot</groupId> </exclusion> </exclusions> </dependency>......war 输入调整 ruoyi-admin 模块下的 pom.xml 文件 <packaging>war</packaging>调整日志在 ruoyi-admin/src/main/resources 新增 logback-spring.xml，原文如下： <?xml version="1.0" encoding="UTF-8"?><configuration>  <property name="log.path" value="/home/root/ruoyi/logs" />  <property name="log.pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - [%method,%line] %X{dd.service} %X{dd.trace_id} %X{dd.span_id} - %msg%n" />  <appender name="console" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <pattern>${log.pattern}</pattern> </encoder> </appender>  <appender name="file_info" class="ch.qos.logback.core.rolling.RollingFileAppender"> <file>${log.path}/sys-info.log</file>  <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">  <fileNamePattern>${log.path}/sys-info.%d{yyyy-MM-dd}.log</fileNamePattern>  <maxHistory>60</maxHistory> </rollingPolicy> <encoder> <pattern>${log.pattern}</pattern> </encoder> <filter class="ch.qos.logback.classic.filter.LevelFilter">  <level>INFO</level>  <onMatch>ACCEPT</onMatch>  <onMismatch>DENY</onMismatch> </filter> </appender> <appender name="file_error" class="ch.qos.logback.core.rolling.RollingFileAppender"> <file>${log.path}/sys-error.log</file>  <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">  <fileNamePattern>${log.path}/sys-error.%d{yyyy-MM-dd}.log</fileNamePattern>  <maxHistory>60</maxHistory> </rollingPolicy> <encoder> <pattern>${log.pattern}</pattern> </encoder> <filter class="ch.qos.logback.classic.filter.LevelFilter">  <level>ERROR</level>  <onMatch>ACCEPT</onMatch>  <onMismatch>DENY</onMismatch> </filter> </appender>  <appender name="sys-user" class="ch.qos.logback.core.rolling.RollingFileAppender"> <file>${log.path}/sys-user.log</file> <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">  <fileNamePattern>${log.path}/sys-user.%d{yyyy-MM-dd}.log</fileNamePattern>  <maxHistory>60</maxHistory> </rollingPolicy> <encoder> <pattern>${log.pattern}</pattern> </encoder> </appender>  <logger name="com.ruoyi" level="info" />  <logger name="org.springframework" level="warn" /> <root level="info"> <appender-ref ref="console" /> </root>  <root level="debug"> <appender-ref ref="file_info" /> <appender-ref ref="file_error" /> </root>  <logger name="sys-user" level="info"> <appender-ref ref="sys-user"/> </logger></configuration> 编译进入我的项目根目录执行以下命令进行编译： ...

关于tomcat:Tomcat目录结构-京东云技术团队

Tomcat目录结构图如下： 1、bin目录寄存一些可执行的二进制文件，.sh 结尾的为linux下执行命令，.bat 结尾的为windows下执行命令。 catalina.sh：真正启动tomcat文件，能够在外面设置jvm参数。startup.sh：启动tomcat（需当时配置好JAVA_HOME环境变量才可启动，该命令源码理论执行的为catalina.sh start）。shutdown.sh：敞开tomcat。version.sh：查看tomcat版本相干信息。2、conf目录寄存tomcat相干配置文件的。 2.1、catalina.policy我的项目平安文件，用来避免坑骗代码或JSP执行带有像System.exit(0)这样的命令，可能影响容器的毁坏。只有当Tomcat用-security命令行参数启动时这个文件才会被应用，即启动tomcat时， startup.sh -security 。 2.2、catalina.proterties配置tomcat启动相干信息文件 2.3、context.xml监督并加载资源文件，当监督文件发生变化时，主动加载，通常不会去配置 2.4、jaspic-providers.xml和jaspic-providers.xsd不罕用文件 2.5、logging.propertiestomcat日志文件配置，包含输入格局、日志级别等。 2.6、server.xml外围配置文件：批改端口号，增加编码格局等外围组件介绍： <1>Server：最顶层元素，而且惟一，代表整个tomcat容器。一个Server元素蕴含一个或者多个Service元素； <2>Service：对外提供服务的。一个Service元素蕴含多个Connector元素，然而只能蕴含一个Engine元素； <3>Connector：接管连贯申请，创立Request和Response对象用于和申请端替换数据；而后调配线程让Engine来解决这个申请，并把产生的Request和Response对象传给Engine <4>Engine：Engine组件在Service组件中有且只有一个；Engine是Service组件中的申请解决组件。Engine组件从一个或多个Connector中接管申请并解决，并将实现的响应返回给Connector，最终传递给客户端。 <5>Host：代表特定的虚拟主机。 <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">**name：**虚拟主机的主机名。比方 localhost 示意本机名称，理论利用时应该填写具体域名，比方 www.dog.com ，当然如果该虚拟主机是给内部人员拜访的，也能够间接填写服务器的 ip 地址，比方 192.168.1.101； **appBase：**设置 Web 应用程序组的门路。appBase 属性的值能够是绝对于 Tomcat 装置目录的相对路径，也能够是绝对路径，须要留神的是该门路必须是 Tomcat 有权限拜访的； **unpackWARs：**是否主动开展war压缩包再运行Web应用程序，默认值为true； **autoDeplay：**是否容许主动部署，默认值是 true，示意 Tomcat 会自动检测 appBase 目录上面的文件变动从而主动利用到正在运行的 Web 应用程序； **deployOnStartup：**为true时，示意Tomcat在启动时查看Web利用，且检测到的所有Web利用视作新利用； <6>Context：该元素代表在特定虚拟主机Host上运行的一个Web利用，它是Host的子容器，每个Host容器能够定义多个Context元素。动态部署Web利用时应用。 <Context path="/" docBase="E:\Resource\test.war" reloadable="true"/>**path：**浏览器拜访时的路径名，只有当主动部署齐全敞开(deployOnStartup和autoDeploy都为false)或docBase不在appBase中时，才能够设置path属性。 **docBase：**动态部署时，docBase能够在appBase目录下，也能够不在；本例中，不在appBase目录下。 **reloadable：**设定我的项目有改变时，从新加载该我的项目。 2.7、tomcat-users.xml和tomcat-users.xsdtomcat-users.xml：tomcat用户配置文件，配置用户名，明码，用户具备权限 tomcat默认没有配置任何用户，只有配置好用户后能力应用以下Tomcat Manager三个性能： <role rolename="manager-gui"/><role rolename="manager-script"/><user username="tomcat" password="tomcat" roles="manager-gui"/><user username="admin" password="123456" roles="manager-script"/>tomcat-users.xsd：对tomcat-users.xml文件的形容和束缚 2.8、web.xmlweb利用相干通用配置，能够做上面这些事件。配置servlet增加过滤器，比方过滤敏感词汇设置session过期工夫，tomcat默认30分钟注册了很多MIME类型，即文档类型。这些MIME类型是客户端与服务器之间阐明文档类型的，如用户申请一个html网页，那么服务器还会通知客户端浏览器响应的文档是text/html类型的，这就是一个MIME类型配置零碎欢送页 3、lib目录寄存tomcat依赖jar包的。其中ecj-x.x.x.jar起到了将.java文件编译成.class字节码文件的作用。 4、logs目录寄存tomcat运行时产生的日志文件。在windows环境中，日志文件输入到catalina.xxxx-xx-xx.log文件中。在linux环境中，日志文件输入到catalina.out文件中。大体有以下几类： catalina.xxxx-xx-xx.logwindows下日志文件输入内容host-manager.xxxx-xx-xx.log拜访webapps下host-manager我的项目日志localhost.xxxx-xx-xx.logtomcat启动时，本身拜访服务，只记录tomcat拜访日志，而非业务我的项目日志localhost\_access\_log.xxxx-xx-xx.txt示意拜访tomcat下所有我的项目日志记录manager.xxxx-xx-xx.log拜访webapps下manager我的项目日志5、temp目录用户寄存tomcat在运行过程中产生的临时文件（清空不会对tomcat运行带来影响）。 6、webapps目录用来寄存应用程序，能够以文件夹、war包、jar包的模式公布利用。当然也能够将应用程序放在磁盘的任意地位，在配置文件中映射好即可。 ...

关于tomcat:请求在tomcat中的流转源码分析篇

Connector的初始化catalina解析server.xml是通过degister来实现的，degister解析到<Connector标签后做的事件如下代码所见 ConnectorCreateRule@Override public void begin(String namespace, String name, Attributes attributes) throws Exception { Service svc = (Service)digester.peek(); Executor ex = null; if ( attributes.getValue("executor")!=null ) { ex = svc.getExecutor(attributes.getValue("executor")); } Connector con = new Connector(attributes.getValue("protocol")); if (ex != null) { setExecutor(con, ex); } String sslImplementationName = attributes.getValue("sslImplementationName"); if (sslImplementationName != null) { setSSLImplementationName(con, sslImplementationName); } digester.push(con); }connector依据标签属性，拿到对应的protocol协定，拿到配在service标签外部的线程池，protocol的名称转化成Connector中ProtocolHandler类型的成员变量, 后续将以Http11NioProtocol来做解说 public Connector(String protocol) { setProtocol(protocol); // Instantiate protocol handler ProtocolHandler p = null; try { Class<?> clazz = Class.forName(protocolHandlerClassName); // 反射调用ProtocolHandler的构造方法的时候会做后续的初始化 p = (ProtocolHandler) clazz.getConstructor().newInstance(); } catch (Exception e) { log.error(sm.getString("coyoteConnector.protocolHandlerInstantiationFailed"), e); } finally { this.protocolHandler = p; }ProtocolHandler的结构ProtocolHandler有其形象办法，Http11NioProtocol构造方法中的tcp实现由NioEndpoint来做，因而Connector结构起来的时候，对应的ProtocolHanlder、endpoint的关联关系曾经关联好 ...

关于tomcat:一次请求在Tomcat源码中的轮转基础篇

前言Tomcat作为Java开发者接触过最重要的web容器，在启动和解决申请过程中做了海量的事件，高级开发者很少关怀，应用SpringMvc之类下层框架一带而过，然而这些局部是Java和网络集大成之作，笔者要带着大家走一遍一次申请，加深tomcat的认知。最好先调试好Tomcat源码 Tomcat基础架构BootStrap和CatalinaBootStrapBootStrap就是Tomcat的main函数所在位置，在应用过程中执行脚本catlina.sh或者bat文件即可执行java命令并调用BootStrap的main函数实现tomcat的启动 public static void main(String args[]) { if (daemon == null) { // Don't set daemon until init() has completed Bootstrap bootstrap = new Bootstrap(); try { bootstrap.init(); } catch (Throwable t) { handleThrowable(t); t.printStackTrace(); return; } daemon = bootstrap; } else { // When running as a service the call to stop will be on a new // thread so make sure the correct class loader is used to // prevent a range of class not found exceptions. Thread.currentThread().setContextClassLoader(daemon.catalinaLoader); }......}CatalinaBootStrap是服务器的入口，会通过start、stop、stopServer、stopServer等反射调用Catalina的对应办法 ...

关于tomcat:springboot-http并发限制

并发限度取决于tomcat配置server.tomcat.max-connections 以后最大连接数server.tomcat.accept-count 最大期待连接数server.tomcat.max-threads 外部参数-最大线程数server.tomcat.min-spare-threads外部参数-最小线程数初始值见spring-configuration-matadata.json 对于外界而言，同一时刻最大连接数 = 以后最大连接数+最大期待连接数。对于外部解决机制而言，request申请先应用最小连接数解决，最小连接数不够则创立线程，直到达到最大线程数。若仍有申请，则扔进线程池阻塞队列，期待线程闲暇时解决。对于http申请客户端次要存在以下三步：1）建设连贯。有连贯超时工夫2）发送申请。即读超时工夫3）期待响应。即写超时工夫

关于tomcat:聊聊springboot-tomcat的maxHttpFormPostSize

序本文次要钻研一下spring boot tomcat的maxHttpFormPostSize参数 parseParameterstomcat-embed-core-9.0.37-sources.jar!/org/apache/catalina/connector/Request.java /** * Parse request parameters. */ protected void parseParameters() { parametersParsed = true; Parameters parameters = coyoteRequest.getParameters(); boolean success = false; try { // Set this every time in case limit has been changed via JMX parameters.setLimit(getConnector().getMaxParameterCount()); // getCharacterEncoding() may have been overridden to search for // hidden form field containing request encoding Charset charset = getCharset(); boolean useBodyEncodingForURI = connector.getUseBodyEncodingForURI(); parameters.setCharset(charset); if (useBodyEncodingForURI) { parameters.setQueryStringCharset(charset); } // Note: If !useBodyEncodingForURI, the query string encoding is // that set towards the start of CoyoyeAdapter.service() parameters.handleQueryParameters(); if (usingInputStream || usingReader) { success = true; return; } String contentType = getContentType(); if (contentType == null) { contentType = ""; } int semicolon = contentType.indexOf(';'); if (semicolon >= 0) { contentType = contentType.substring(0, semicolon).trim(); } else { contentType = contentType.trim(); } if ("multipart/form-data".equals(contentType)) { parseParts(false); success = true; return; } if( !getConnector().isParseBodyMethod(getMethod()) ) { success = true; return; } if (!("application/x-www-form-urlencoded".equals(contentType))) { success = true; return; } int len = getContentLength(); if (len > 0) { int maxPostSize = connector.getMaxPostSize(); if ((maxPostSize >= 0) && (len > maxPostSize)) { Context context = getContext(); if (context != null && context.getLogger().isDebugEnabled()) { context.getLogger().debug( sm.getString("coyoteRequest.postTooLarge")); } checkSwallowInput(); parameters.setParseFailedReason(FailReason.POST_TOO_LARGE); return; } byte[] formData = null; if (len < CACHED_POST_LEN) { if (postData == null) { postData = new byte[CACHED_POST_LEN]; } formData = postData; } else { formData = new byte[len]; } try { if (readPostBody(formData, len) != len) { parameters.setParseFailedReason(FailReason.REQUEST_BODY_INCOMPLETE); return; } } catch (IOException e) { // Client disconnect Context context = getContext(); if (context != null && context.getLogger().isDebugEnabled()) { context.getLogger().debug( sm.getString("coyoteRequest.parseParameters"), e); } parameters.setParseFailedReason(FailReason.CLIENT_DISCONNECT); return; } parameters.processParameters(formData, 0, len); } else if ("chunked".equalsIgnoreCase( coyoteRequest.getHeader("transfer-encoding"))) { byte[] formData = null; try { formData = readChunkedPostBody(); } catch (IllegalStateException ise) { // chunkedPostTooLarge error parameters.setParseFailedReason(FailReason.POST_TOO_LARGE); Context context = getContext(); if (context != null && context.getLogger().isDebugEnabled()) { context.getLogger().debug( sm.getString("coyoteRequest.parseParameters"), ise); } return; } catch (IOException e) { // Client disconnect parameters.setParseFailedReason(FailReason.CLIENT_DISCONNECT); Context context = getContext(); if (context != null && context.getLogger().isDebugEnabled()) { context.getLogger().debug( sm.getString("coyoteRequest.parseParameters"), e); } return; } if (formData != null) { parameters.processParameters(formData, 0, formData.length); } } success = true; } finally { if (!success) { parameters.setParseFailedReason(FailReason.UNKNOWN); } } }tomcat request解析表单参数maxPostSize次要是上面这段 ...

关于tomcat:基于嵌入式Tomcat的War包启动器

前言最近针对java我的项目的部署形式进行整顿，jenkins/tomcat/windows工具/linux脚本/web部署平台等等发现war包通过tomcat部署比拟繁琐，等待时间长，配置规定简单对于小白很不敌对，也难以接入到自定义的部署工具/平台中之前开发的Jar包部署平台是servlet开发通过嵌入式tomcat部署，借此关上思路是否基于嵌入式tomcat做一个war包启动器，通过代码的形式开启tomcat容器来部署war包源码地址：https://gitee.com/code2roc/jar-manage/tree/master/waragent 借此启动器能够将war包部署集成到本人的工具平台中，将启动器的jar包按一般形式部署即可计划tomcat启动个别须要几个根本参数设置 war包门路端口映射路由Tomcat tomcat = new Tomcat();tomcat.setPort(port);StandardContext ctx = (StandardContext) tomcat.addWebapp(contextPath, catalinaBase + File.separator + "webapps" + File.separator + name + ".war");tomcat9启动还须要指定cookie解决策略，否则无奈辨认 CookieProcessor cookieProcessor = new LegacyCookieProcessor();ctx.setCookieProcessor(cookieProcessor);后续理论应用中还波及到了启动jvm参数设置及jar包扫描跳过的配置 tomcat.getEngine().setJvmRoute(jvmStartCommand);StandardJarScanner jarScanner = new StandardJarScanner();StandardJarScanFilter jarScanFilter = new StandardJarScanFilter();jarScanFilter.setTldSkip(skipScan);jarScanFilter.setPluggabilitySkip(skipScan);jarScanner.setJarScanFilter(jarScanFilter);ctx.setJarScanner(jarScanner)打包原来料想把maven我的项目打到一个jar包不便调用，然而打包插件会把依赖jar包中的class文件进行合并嵌入式tomcat依赖的jar包有雷同包名的，导致class文件笼罩，websocket相干内容报错所以把依赖jar包打入到同级lib文件夹中，和waranaget.jar一起拷贝应用 <build> <finalName>${artifactId}</finalName> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <configuration> <archive> <manifest> <addClasspath>true</addClasspath> <classpathPrefix>lib/</classpathPrefix> <mainClass>com.code2roc.waragent.Application</mainClass> </manifest> </archive> </configuration> </plugin>  <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <executions> <execution> <id>copy</id> <phase>package</phase> <goals> <goal>copy-dependencies</goal> </goals> <configuration> <outputDirectory> ${project.build.directory}/lib </outputDirectory> </configuration> </execution> </executions> </plugin> </plugins> </build>应用java -jar waragent.jar "启动参数" ...

关于tomcat:Tomcat处理http请求之源码分析-京东云技术团队

本文将从申请获取与包装解决、申请传递给Container、Container解决申请流程，这3局部来讲述一次http穿梭之旅。 1 申请包装解决tomcat组件Connector在启动的时候会监听端口。以JIoEndpoint为例，在其Acceptor类中： protected class Acceptor extends AbstractEndpoint.Acceptor { @Override public void run() { while (running) { …… try { //以后连接数 countUpOrAwaitConnection(); Socket socket = null; try { //取出队列中的连贯申请 socket = serverSocketFactory.acceptSocket(serverSocket); } catch (IOException ioe) { countDownConnection(); } if (running && !paused && setSocketOptions(socket)) { //解决申请 if (!processSocket(socket)) { countDownConnection(); closeSocket(socket); } } else { countDownConnection(); // Close socket right away closeSocket(socket); } } …… } }}在下面的代码中，socket = serverSocketFactory.acceptSocket(serverSocket);与客户端建设连贯，将连贯的socket交给processSocket(socket)来解决。在processSocket中，对socket进行包装一下交给线程池来解决： ...

关于tomcat:玩转服务器之Java-Web篇手把手教你搭建Java-Web环境-京东云技术团队

前言Java Web我的项目，简略来说就是咱们在浏览器上能够看到的内容。就简略的Web来说，服务器上也同样须要有计算机上所须要的运行环境，如：java,tomcat,mysql 。Java Web环境能够用来开发和部署各种Web应用程序，例如网站、Web服务、Web后盾管理系统等。特点是跨平台、可靠性高、安全性强、开发效率低等。本篇文章会给你比拟具体的教程，从最根本的开始，循序渐进的深刻。一、Java Web 环境介绍Java是一门面向对象的编程语言，是目前支流的开发语言之一。本文以轻量云主机（CenTOS 7.6零碎）为例，应用OpenJDK 和 Tomcat 8 演示 Java Web 环境的搭建。二、前置筹备正式开始部署前，您需实现如下的筹备工作：开明京东云账户，若您还未注册京东云账号，可在京东云官网进行注册；账户开明后，须要进行实名认证；购买一台或多台云主机或者轻量云主机产品；登录轻量云主机，复制上面步骤中的命令进行执行操作；上面操作步骤需主机凋谢8080端口，请在防火墙中配置端口凋谢策略。三、装置OpenJDK 8yum install java-1.8.0-openjdk装置结束显示如下：四、装置tomcat下载tomcat，如果提醒没有certificate，请先下载证书。 wget https://dlcdn.apache.org/tomcat/tomcat-8/v8.5.87/bin/apache-tomcat-8.5.87.tar.gz 解压tomcat tar -zxvf ./apache-tomcat-8.5.87.tar.gz解压实现后生成apache-tomcat-8.5.87目录五、启动tomcat进入tomcat的bin目录执行startup.sh cd ./apache-tomcat-8.5.87/bin./startup.sh启动胜利显示如下：通过curl测试是否启动胜利 curl http://localhost:8080 在浏览器中拜访形式ip:8080, 如下图所示。如果拜访失败，请查看防火墙策略是否开启了8080端口。到此，咱们的Java Web环境，就曾经装置配置实现，前面咱们就能够进行开发啦。

关于tomcat:请求量突增一下系统有效QPS为何下降很多

原创：扣钉日记（微信公众号ID：codelogs），欢送分享，转载请保留出处。简介最近我察看到一个景象，当服务的申请量突发的增长一下时，服务的无效QPS会降落很多，有时甚至会降到0，这种景象网上也偶有提到，但少有解释得分明的，所以这里来分享一下问题成因及解决方案。队列提早目前的Web服务器，如Tomcat，申请处理过程大略都相似如下：这是Tomcat申请解决的过程，如下： Acceptor线程：线程名相似http-nio-8080-Acceptor-0，此线程用于接管新的TCP连贯，并将TCP连贯注册到NIO事件中。Poller线程：线程名相似http-nio-8080-ClientPoller-0，此线程个别有CPU核数个，用于轮询已连贯的Socket，接管新到来的Socket事件（如调用端发申请数据了），并将沉闷Socket放入exec线程池的申请队列中。exec线程：线程名相似http-nio-8080-exec-0，此线程从申请队列中取出沉闷Socket，并读出申请数据，最初执行申请的API逻辑。这里不必太关怀Acceptor与Poller线程，这是nio编程时常见的线程模型，咱们将重点放在exec线程池上，尽管Tomcat做了一些优化，但它还是从Java原生线程池扩大进去的，即有一个工作队列与一组线程。当申请量突发增长时，会产生如下的状况：当申请量不大时，工作队列根本是空的，每个申请都能失去及时的解决。但当申请量突发时，工作队列中就会有很多申请，这时排在队列前面的申请，就会被解决得越晚，因此申请的整体耗时就会变长，甚至十分长。可是，exec线程们还是在一刻不停歇的解决着申请的呀，按理说服务QPS是不会缩小的呀！简略想想的确如此，但调用端个别是有超时工夫设置的，不会有限期待上来，当客户端期待超时的时候，这个申请实际上Tomcat就不必再解决了，因为就算解决了，客户端也不会再去读响应数据的。因而，当队列比拟长时，队列前面的申请，基本上都是不必再解决的，但exec线程池不晓得啊，它还是会判若两人地解决这些申请。当exec线程执行这些已超时的申请时，若又有新申请进来，它们也会排在队尾，这导致这些新申请也会超时，所以在流量突发的这段时间内，申请的无效QPS会降落很多，甚至会降到0。这种超时也叫做队列提早，但队列在软件系统中利用得太宽泛了，比方操作系统调度器保护了线程队列，TCP中有backlog连贯队列，锁中保护了期待队列等等。因而，很多零碎也会存在这种景象，平时响应工夫挺稳固的，但偶然耗时很高，这种状况有很多都是队列提早导致的。优化队列提早晓得了问题产生的起因，要优化它就比较简单了，咱们只须要让队列中那些长时间未解决的申请临时让路，让线程去执行那些等待时间不长的申请即可，毕竟这些长时间未解决的申请，让它们再等等也无防，因为客户端可能曾经超时了而不须要申请后果了，尽管这毁坏了队列的公平性，但这是咱们须要的。对于Tomcat，在springboot中，咱们能够如下批改：应用WebServerFactoryCustomizer自定义Tomcat的线程池，如下： @Componentpublic class TomcatExecutorCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> { @Resource ServerProperties serverProperties; @Override public void customize(TomcatServletWebServerFactory factory) { TomcatConnectorCustomizer tomcatConnectorCustomizer = connector -> { ServerProperties.Tomcat.Threads threads = serverProperties.getTomcat().getThreads(); TaskQueue taskqueue = new SlowDelayTaskQueue(1000); ThreadPoolExecutor executor = new org.apache.tomcat.util.threads.ThreadPoolExecutor( threads.getMinSpare(), threads.getMax(), 60L, TimeUnit.SECONDS, taskqueue, new CustomizableThreadFactory("http-nio-8080-exec-")); taskqueue.setParent(executor); ProtocolHandler handler = connector.getProtocolHandler(); if (handler instanceof AbstractProtocol) { AbstractProtocol<?> protocol = (AbstractProtocol<?>) handler; protocol.setExecutor(executor); } }; factory.addConnectorCustomizers(tomcatConnectorCustomizer); }}留神，这里还是应用的Tomcat实现的线程池，只是将工作队列TaskQueue扩大为了SlowDelayTaskQueue，它的作用是将长时间未解决的工作移到另一个慢队列中，待以后队列中无工作时，再把慢队列中的工作移回来。 ...

关于tomcat:tomcat的启动过程和原理

　1、背景 SpringBoot是一个框架，一种全新的编程标准，他的产生简化了框架的应用，同时也提供了很多便捷的性能，比方内置tomcat就是其中一项，他让咱们省去了搭建tomcat容器，生成war，部署，启动tomcat。因为内置了启动容器，应用程序能够间接通过Maven命令将我的项目编译成可执行的jar包，通过java-jar命令间接启动，不须要再像以前一样，打包成War包，而后部署在Tomcat中，那么内置tomcat是如何实现的呢？ 2、tomcat启动过程及原理 2.1、下载一个springboot我的项目在这里下载一个我的项目https://start.spring.io/也能够在idea新建SpringBoot-Web工程。 <dependency>　<groupId>org.springframework.boot</groupId>　<artifactId>spring-boot-starter-web</artifactId>　</dependency>　点击pom.xml会有tomcat依赖 <dependency>　<groupId>org.springframework.boot</groupId>　<artifactId>spring-boot-starter-tomcat</artifactId>　<version>2.1.2.RELEASE</version>　<scope>compile</scope>　</dependency>　2.2、从启动入口开始一步步摸索点击进入run办法 public static ConfigurableApplicationContext run(Class<?> primarySource,　String... args) {　return run(new Class<?>[] { primarySource }, args);　}　//持续点击进入run办法　public static ConfigurableApplicationContext run(Class<?>[] primarySources,　String[] args) {　return new SpringApplication(primarySources).run(args);　}　进入到这个run办法之后就能够看到，咱们意识的一些初始化事件。次要的过程也是在这里实现的。 2.3、源码代码流程大抵是这样 /**　* Run the Spring application, creating and refreshing a new　* {@link ApplicationContext}.　* @param args the application arguments (usually passed from a Java main method)　* @return a running {@link ApplicationContext}　*/　public ConfigurableApplicationContext run(String... args) {　StopWatch stopWatch = new StopWatch();　stopWatch.start();　ConfigurableApplicationContext context = null;　Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();　/**1、配置零碎属性*/　configureHeadlessProperty();　/**2.获取监听器*/　SpringApplicationRunListeners listeners = getRunListeners(args);　/**公布利用开始启动事件 */　listeners.starting();　try {　/** 3.初始化参数 */　ApplicationArguments applicationArguments = new DefaultApplicationArguments(　args);　/** 4.配置环境*/　ConfigurableEnvironment environment = prepareEnvironment(listeners,　applicationArguments);　configureIgnoreBeanInfo(environment);　Banner printedBanner = printBanner(environment);　/**5.创立利用上下文*/　context = createApplicationContext();　exceptionReporters = getSpringFactoriesInstances(　SpringBootExceptionReporter.class,　new Class[] { ConfigurableApplicationContext.class }, context);　/**6.预处理上下文*/　prepareContext(context, environment, listeners, applicationArguments,　printedBanner);　/**6.刷新上下文*/　refreshContext(context);　afterRefresh(context, applicationArguments);　stopWatch.stop();　if (this.logStartupInfo) {　new StartupInfoLogger(this.mainApplicationClass)　.logStarted(getApplicationLog(), stopWatch);　}　/** 8.公布利用曾经启动事件 */　listeners.started(context);　callRunners(context, applicationArguments);　}　catch (Throwable ex) {　handleRunFailure(context, ex, exceptionReporters, listeners);　throw new IllegalStateException(ex);　}　try {　/** 9.公布利用曾经启动实现的监听事件 */　listeners.running(context);　}　catch (Throwable ex) {　handleRunFailure(context, ex, exceptionReporters, null);　throw new IllegalStateException(ex);　}　return context;　}　代码中次要就是通过switch语句，依据webApplicationType的类型来创立不同的ApplicationContext： ...

关于tomcat:Bug解决思路Tomcat返回不安全的响应头

背景概述公司平安测试要求接口的申请办法只能是GET, POST，并且响应头也只能为GET, POST. 问题形容在理解到这个需要后，我在过滤器对所有进入服务的申请对立设置响应头： @WebFilter(urlPatterns = "/*", filterName = "GlobalFilter")public class GlobalFilter implements Filter { @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException { log.info(">>>>>>>>>>>>>>>>>>>> doFilter <<<<<<<<<<<<<<<<<<<<"); HttpServletRequest request = (HttpServletRequest) servletRequest; HttpServletResponse response = (HttpServletResponse) servletResponse; response.setHeader("Access-Control-Allow-Origin", "*"); response.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS"); response.setHeader("Access-Control-Allow-Headers", request.getHeader("Access-Control-Request-Headers")); filterChain.doFilter(servletRequest, response); }}写这段代码是因为我下意识地认为只有设置一个全局的响应头，将 Access-Control-Allow-Methods 设置为GET,POST 就能够轻松实现测试提出的，响应头只能为GET, POST的需要. 这段代码帮我解决了大部分问题，我在自测时“GET,HEAD,POST,PUT,DELETE,OPTIONS”它们的响应头都胜利返回了 GET、POST。贴一张 OPTIONS 申请的截图，他的Allow-Methos胜利的返回了 GET,POST. 到这你是不是感觉问题就曾经解决了？并没有，事件没这么简略，测试很快就让我打脸了，请看下图，当 uri 改为 * 时，Allow 的返回值让我不敢相信本人的眼睛。问题剖析在应用 burpsuite 复现问题时，我发现服务的过滤器并没有拦挡到 options * 申请，也就是说申请在进入过滤器前就曾经被解决并响应了。 ...

关于tomcat:tomcat-端口-8005-被-windows-系统服务占用导致启动闪退的问题

我的 tomcat 装置在这个目录下：C:\app\tomcat-9.0.56 执行 bin 文件夹下的 startup.bat 时，遇到闪退的问题。查看 logs 文件夹下的日志文件 catalina.2022-10-29.log：遇到如下谬误音讯： HostConfig.deployDirectory Deployment of web application directory [C:\app\tomcat-9.0.56\webapps\ROOT] has finished in [37] ms29-Oct-2022 17:21:47.262 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["http-nio-8080"]29-Oct-2022 17:21:47.951 INFO [main] org.apache.catalina.startup.Catalina.start Server startup in [2830] milliseconds29-Oct-2022 17:21:47.963 SEVERE [main] org.apache.catalina.core.StandardServer.await Failed to create server shutdown socket on address [localhost] and port [8005] (base port [8005] and offset [0])java.net.BindException: Address already in use: NET_Bind at java.base/java.net.PlainSocketImpl.bind0(Native Method) at java.base/java.net.PlainSocketImpl.socketBind(PlainSocketImpl.java:132) at java.base/java.net.AbstractPlainSocketImpl.bind(AbstractPlainSocketImpl.java:452) ...

关于tomcat:88tomcat-指定目录部署的配置完整的serverxml

<?xml version="1.0" encoding="UTF-8"?><Server port="8102" shutdown="SHUTDOWN"> <Listener className="org.apache.catalina.startup.VersionLoggerListener" />   <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" /> <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" /> <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />  <GlobalNamingResources>  <Resource name="UserDatabase" auth="Container" type="org.apache.catalina.UserDatabase" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" pathname="conf/tomcat-users.xml" /> </GlobalNamingResources>  <Service name="Catalina">    <Connector port="8002" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />        <Connector port="8202" protocol="AJP/1.3" redirectPort="8443" />   <Engine name="Catalina" defaultHost="localhost">    <Realm className="org.apache.catalina.realm.LockOutRealm">  <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase"/> </Realm> <Host name="127.0.0.1" appBase="webapps" unpackWARs="true" autoDeploy="true"> <Alias>s114.tomcat</Alias>    <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log" suffix=".txt" pattern="%h %l %u %t "%r" %s %b" /> </Host> <Host name="localhost" appBase="_empty" unpackWARs="true" autoDeploy="true"> </Host> <Host name="js.homlin.com" appBase="_empty" unpackWARs="true" autoDeploy="true"> <Context path="" docBase="E:\webapps\js.homlin.com\webapp" sessionCookiePath="/" /> <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="js.homlin.com/access_log." suffix=".txt" pattern="%h %l %u %t "%r" %s %b" /> </Host> </Engine> </Service></Server>

关于tomcat:startupbat一闪而过

这次关上tomcat。startup.bat又一闪而过了，我想了想难道是前两天的没弄好么，不对啊，我记得曾经好了，我过来看了看，发现之前改的配置还在，那证实不是上次的问题，接下来找找问题。一、问题解决样再startup.bat前面加上pause，在窗口上发现环境变量已启动。 startup.bat启动tomcat时流程是：startup->catalina->setclasspath->catalina 为了更具体的看到信息，咱们找到call "%EXECUTABLE%" start %CMD_LINE_ARGS% 把外面的start替换为run。发现起因是server.xml文件找不到了，果然我关上conf文件夹发现server.xml文件，发现没有server.xml文件，可能是改文件的时候不晓得弄哪去了，加上了就好了。二、error occurred during initialization of vm could not reserve enough space for object heap could not create the java virtual machine当呈现这个谬误是，这是咱们须要设置tomcat利用内存了。剖析起因：因为程序初始化时申请不到足够的内存，导致vm程序退出解决办法：设置tomcat的利用内存，在catalina.bat中找到Execute The Requested Command上面的set JAVA_OPTS把这一句替换为 set JAVA_OPTS= -Xms800m -Xmx800m 或者 set JAVA_OPTS= -server -Xms800m -Xmx800m -XX:MaxNewSize=256m 阐明： - Xms为tomcat启动初始内存 - Xmx为tomcat最大占用内存，以上两个参数关系到tomcat接受的拜访性能，但也要依据服务器理论内存状况设定。

关于tomcat:tomcatThis-environment-variable-is-needed-to-run-this-program

明天应用皕杰平台启动tomcat时，startup.bat一闪而过，咱们在startup.bat外面end前面加上pause，这是咱们就会发现报This environment variable is needed to run this program这个错，这是JAVA_HOME的环境变量配置出错，而后我去查看了环境变量，奇怪配置的没有错。个别通过startup.bat启动tomcat时流程是：startup->catalina->setclasspath->catalina，最初找到解决方案如下。进入cmd命令行窗口，cd进入到Tomcat的bin文件夹，在bin下输出startup.bat，运行tomcat，报如下谬误： The JRE_HOME environment variable is not defined correctly This environment variable is needed to run this program 首先咱们检测本人电脑jdk有没有装好：进行cmd命令行窗口，输出javac等指令都能够，如果没问题的话，那就是少了上面配置 1.用记事本关上tomcat/bin/setclasspath.bat 2.在最后面增加代码，jdk根目录，相当于间接给出JAVA_HOME和JRE_HOME门路 eg: set JAVA_HOME=C:\Program Files\Java\jdk1.8.0_202 只设置JAVA_HOME就行，JRE_HOME 当初不须要了，如下图第一行所示，上面那个jre不必写了接下来保留，启动胜利。

关于tomcat:tomcat的webapps目录下的应用删除部署

1.tomcat9的webapps下利用的拜访tomcat9的server.xml文件中 <Host>下须要加一段： <Context docBase="/xxx/tomcat9/webapps/xxx" path="/" reloadable="true"></Context>改完后大抵为： <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true"> <Context docBase="/xxx/tomcat9/webapps/xxx" path="/" reloadable="true"></Context>留神： path="/" 意思是，相当于指定此利用作为和默认时ROOT的拜访形式-->根目录拜访localhost 能够改为具体的域名，比方 www.niewj.com,具体理论看你的域名2. 进一步：删除webapps下所有目录，只留本人利用2.1 删除阐明docs、examples和ROOT这几个文件夹是能够间接删除的；host-manager和manager删除后会有日志告警，要打消，须要做如下操作2.2 须要删除的内容tomcat/conf/logging.properties 删除局部配置： [1] handlers删除两项： 3manager.org.apache.juli.AsyncFileHandler, 4host-manager.org.apache.juli.AsyncFileHandler,[2] 上面该两项相干的也都删掉(注掉即可)： # 3manager.org.apache.juli.AsyncFileHandler.level = FINE# 3manager.org.apache.juli.AsyncFileHandler.directory = ${catalina.base}/logs# 3manager.org.apache.juli.AsyncFileHandler.prefix = manager.# 3manager.org.apache.juli.AsyncFileHandler.maxDays = 90# 3manager.org.apache.juli.AsyncFileHandler.encoding = UTF-8# 4host-manager.org.apache.juli.AsyncFileHandler.level = FINE# 4host-manager.org.apache.juli.AsyncFileHandler.directory = ${catalina.base}/logs# 4host-manager.org.apache.juli.AsyncFileHandler.prefix = host-manager.# 4host-manager.org.apache.juli.AsyncFileHandler.maxDays = 90# 4host-manager.org.apache.juli.AsyncFileHandler.encoding = UTF-83. 小结而后，webapps 下所有都删掉，只保留本人业务相干的利用即可，而且配合第一点，间接localhost:8080/拜访就是本人的利用。参考：https://blog.csdn.net/flyinga...

关于tomcat:Tomcat原理剖析tomcat介绍和源码idea构建

一、Tomcat 介绍1.1 什么是TomcatTomcat 服务器是一个开源的轻量级Web应用服务器，在中小型零碎和并发量小的场合下被广泛应用，是开发和调试Servlet、JSP 程序的首选。简直所有Java程序员初期都会应用它，明天咱们就带着大家深刻Tomcat底层原理。除了tomcat服务器，咱们还能够应用其余的web服务器，那常见还还有以下这些： Undertow：是一个采纳 Java 开发的灵便的高性能 Web 服务器，提供包含阻塞和基于 NIO 的非梗塞机制。JBoss：JBoss公司的，大型的JavaEE服务器，反对所有的JavaEE标准，免费的。WebLogic：Oracle公司，大型的JavaEE服务器，反对所有的JavaEE标准，免费的。WebSphere：IBM公司，大型的JavaEE服务器，反对所有的JavaEE标准，免费的。历史沿革 Tomcat 最后由Sun公司的软件架构师 James Duncan Davidson 开发，名称为 “JavaWebServer”。1999年，在 Davidson 的帮忙下，该我的项目于 1999 年于apache 软件基金会旗下的 JServ 我的项目合并，并公布第一个版本（3.x）, 即是当初的Tomcat，该版本实现了Servlet2.2 和 JSP 1.1 标准。2001年，公布4.0版本，作为里程碑式的版本，Tomcat 齐全从新设计了其架构，并实现了 Servlet2.3 和 JSP1.2标准。2003年，公布5.0版本，实现 Servlet 2.4 和 JSP2.0标准。2007年，公布6.0版本，实现 Servlet 2.5 、JSP2.1 标准。反对EL1.1标准。2011年，公布7.0版本，实现 Servlet 3.0 和 JSP2.2标准。反对EL2.2标准。退出了WebSocket规范。2014年，公布8.0版本，实现 Servlet 3.1 和 JSP2.3标准。反对EL3.0标准。2016年，公布8.5版本，实现 Servlet 3.1 和 JSP2.3标准。反对HTTP/2，OpenSSL，TLS虚拟主机和JASPIC1.1。2018年，公布9.0版本，实现 Servlet 4.0 标准。目前 Tomcat 曾经更新到 10.0.x版本，然而目前企业中的Tomcat服务器，支流版本是8.5 ，所以本课程是基于 8.5 版本进行解说。 ...

关于tomcat:Linux系统安装Tomcat

Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 我的项目中的一个外围我的项目，由Apache、Sun 和其余一些公司及集体共同开发而成。因为有了Sun 的参加和反对，最新的Servlet 和JSP 标准总是能在Tomcat 中失去体现，Tomcat 5反对最新的Servlet 2.4 和JSP 2.0 标准。因为Tomcat 技术先进、性能稳固，而且收费，因此深受Java 爱好者的青睐并失去了局部软件开发商的认可，成为比拟风行的Web 应用服务器。 1、首先去官网下载安装包https://tomcat.apache.org/dow...Tomcat须要在jdk的环境下，能够参考之前的文件装置 2、解压安装包 tar zxvf apache-tomcat-8.5.16.tar.gz -C /opt/ 3、挪动文件夹并命名为tomcat mv apache-tomcat-8.5.16 /usr/local/tomcat8 4、敞开防火墙systemctl stop firewalld.service 5、启动Tomcat/usr/local/tomcat8/bin/startup.sh 6、监听端口，看是否胜利，而后到浏览器输出ip：8080拜访页面netstat -ntap | grep 8080 我的试验环境是租的服务器，他们的价格便宜而且带宽高，不便做试验

关于tomcat:问题记录TomcatTomcat启动报错Possiblefor-Xss-and-illegal

Tomcat启动报错：Possible root causes include a too low setting for -Xss and illegal cyclic inheritance dependencies错误代码如下： Caused by: java.lang.IllegalStateException: Unable to complete the scan for annotations for web application [] due to a StackOverflowError. Possible root causes include a too low setting for -Xss and illegal cyclic inheritance dependencies. The class hierarchy being processed was [org.bouncycastle.asn1.ASN1Boolean->org.bouncycastle.asn1.DERBoolean->org.bouncycastle.asn1.ASN1Boolean] at org.apache.catalina.startup.ContextConfig.checkHandlesTypes(ContextConfig.java:2139) at org.apache.catalina.startup.ContextConfig.processAnnotationsStream(ContextConfig.java:2083) at org.apache.catalina.startup.ContextConfig.processAnnotationsJar(ContextConfig.java:2029) at org.apache.catalina.startup.ContextConfig.processAnnotationsUrl(ContextConfig.java:1999) at org.apache.catalina.startup.ContextConfig.processAnnotations(ContextConfig.java:1952) at org.apache.catalina.startup.ContextConfig.webConfig(ContextConfig.java:1156) at org.apache.catalina.startup.ContextConfig.configureStart(ContextConfig.java:765) at org.apache.catalina.startup.ContextConfig.lifecycleEvent(ContextConfig.java:299) at org.apache.catalina.util.LifecycleBase.fireLifecycleEvent(LifecycleBase.java:123) at org.apache.catalina.core.StandardContext.startInternal(StandardContext.java:4989) at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:183) ... 42 more网上给的答案都是调整Xss参数，其实不是正确的做法， ...

关于tomcat:tomcat如何调试源码

目录构造先看下整体的目录构造是什么样子，以及每个内容的作用，而后前面讲怎么失去这些内容。下载源码去官网下载2个货色一个是源码我的项目，一个是作为工作目录。目录构造是怎么来的？先创立一个根目录，作为我的项目根目录。而后把方才下载的2个货色，解压之后，复制到根目录。最初，手动创立2个pom文件： 1.我的项目根目录 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>gxf</groupId> <artifactId>apache-tomcat-9</artifactId> <name>apache-tomcat-9-source</name> <version>1.0</version> <packaging>pom</packaging> <modules> <module>apache-tomcat-8.5.81-src</module> </modules> </project>2.源码我的项目目录 <?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>org.apache.tomcat</groupId> <artifactId>Tomcat9.0</artifactId> <name>Tomcat9.0</name> <version>9.0</version> <build> <finalName>Tomcat9.0</finalName> <sourceDirectory>java</sourceDirectory> <testSourceDirectory>test</testSourceDirectory> <resources> <resource> <directory>java</directory> </resource> </resources> <testResources> <testResource> <directory>test</directory> </testResource> </testResources> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>2.0.2</version> <configuration> <encoding>UTF-8</encoding> <source>1.8</source> <target>1.8</target> </configuration> </plugin> </plugins> </build> <dependencies> <dependency> <groupId>ant</groupId> <artifactId>ant</artifactId> <version>1.7.0</version> </dependency> <dependency> <groupId>ant</groupId> <artifactId>ant-apache-log4j</artifactId> <version>1.6.5</version> </dependency> <dependency> <groupId>ant</groupId> <artifactId>ant-commons-logging</artifactId> <version>1.6.5</version> </dependency> <dependency> <groupId>wsdl4j</groupId> <artifactId>wsdl4j</artifactId> <version>1.6.2</version> </dependency> <dependency> <groupId>javax.xml.rpc</groupId> <artifactId>javax.xml.rpc-api</artifactId> <version>1.1</version> </dependency> <dependency> <groupId>org.eclipse.jdt.core.compiler</groupId> <artifactId>ecj</artifactId> <version>4.6.1</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency>  <dependency> <groupId>org.easymock</groupId> <artifactId>easymock</artifactId> <version>4.3</version> <scope>test</scope> </dependency>  <dependency> <groupId>com.unboundid</groupId> <artifactId>unboundid-ldapsdk</artifactId> <version>5.1.4</version> <scope>test</scope> </dependency> </dependencies></project>idea配置筹备好内容之后，导入idea(导入之后，就是目录构造里展现的那样)，而后须要配置一些货色。 ...

关于tomcat:tomcat源码分析如何接收连接如何读数据

外围流程脑图监听端口外围步骤 1.创立服务器套接字 2.监听端口接管连贯外围步骤：接管客户端连贯。总结接管客户端连贯，是一个专门的线程。说白了，就是这个线程，专门干这个事件：只接管客户端连贯。从客户端读数据是读线程池解决。监听读事件外围步骤 1.监听都事件一直轮询读事件 2.获取读事件 3.解决读事件即读数据，最终是交给读线程池读数据轮询读事件解决读事件具体是交给读线程池解决读数据总结 1.监听事件线程监听事件是一个独立的线程，专门用于监听事件，实质是一直轮询事件。 2.读数据线程池最终的读数据是交给读数据线程池去执行。为什么？因为读数据比较慢。读数据外围步骤：读数据。读数据：调用servlet类的service办法架构图流程图读线程池在哪里创立？在监听端口的时候，就曾经创立了。真正创立读线程池的中央读线程池配置(最小10，最大200-这里就是tomcat默认200的起源)。

关于tomcat:tomcat源码分析

https://blog.csdn.net/nmjhehe...

关于tomcat:Tomcat改jar

Tomcat改jar插件批改 <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <mainClass>HuanProviderApplication</mainClass> </configuration> </plugin>主类批改package com;import com.fedtech.commons.util.SpringContextUtils;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;import org.springframework.boot.builder.SpringApplicationBuilder;import org.springframework.boot.web.support.SpringBootServletInitializer;import org.springframework.context.annotation.Bean;import org.springframework.scheduling.annotation.EnableScheduling;@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})@EnableSchedulingpublic class HuanProviderApplication extends SpringBootServletInitializer { public static void main(String[] args) { System.setProperty("spring.devtools.restart.enabled", "false"); SpringApplication.run(HuanProviderApplication.class, args); } @Bean public SpringContextUtils springContextUtils(){ return new SpringContextUtils(); }// @Override// protected SpringApplicationBuilder configure(SpringApplicationBuilder application){// return application.sources(HuanProviderApplication.class);// }} 打包形式批改<artifactId>huan-provider</artifactId><packaging>jar</packaging><dependencies>

关于tomcat:关于本地Tomcat服务器的内网穿透

相干TomcatTomcat服务器是一个开源的轻量级Web应用服务器下载地址Apache Tomcat® - Welcome!网云穿内网穿透工具，大略作用就是把本地的服务器的我的项目公布到外网下载地址网云穿内网穿透 (xiaomy.net) 步骤1.进入网云穿的官网后点击登录注册，新用户能够支付一条收费隧道2.支付完隧道之后，会跳转到控制台让咱们配置隧道信息，输出相干信息即可3.ipv4的查问：win+r输出cmd关上命令提示符，输出ipconfig能够查问到本机IP地址如图： 4.绑定Tomcat的端口，Tomcat服务器的默认端口为8080，Apache服务器的默认端口为80，也能够本人更改服务器的端口号，到服务器的配置文件，在conf目录上面关上server.xml文件 <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />批改8080后保留重启服务即可启动下载网云穿客户端，启动隧道协定+映射地址+服务，公网上拜访即可

关于tomcat:深入源码了解Tomcat加载servlet的过程

Tomcat加载servlet过程有人活了大半辈子还不晓得servlet是啥？它在tomcat中又是怎么生存的呢？来，安顿上~~ 让咱们把回顾拉回到很久很久以前，呃，就是 springboot 启动的工夫点，找到 ServletWebServerApplicationContext#refresh() 这个办法，走上来，是 onRefresh() 办法里的createWebServer() 办法，点开它：这里以 dispatcherServlet 的加载为例，待会就盯着她。点开getSelfInitializer()办法，在要害中央打个断点：能够看到，这里通过getServletContextInitializerBeans()办法，获取到所有的 ServletContextInitializer进行遍历，调用各自的 onStartup()。在遍历到 DispatcherServletRegistrationBean的时候，进入 onStartup()办法看看：曾经看到dispatcherServlet了，感觉离胜利不远啰~ 点 register(description, servletContext)进去：再点 addRegistration()进入，拼上最初一口气，追到这里，看要害代码： private ServletRegistration.Dynamic addServlet(String servletName, String servletClass, Servlet servlet, Map<String,String> initParams) throws IllegalStateException { …… // 查找context里是否有该servlet（这里的context是TomcatEmbeddedContext， // servletName是 dispatcherServlet） Wrapper wrapper = (Wrapper) context.findChild(servletName); // 查找不到，则创立一个增加到context中。Wrappe 封装了servlet if (wrapper == null) { wrapper = context.createWrapper(); wrapper.setName(servletName); context.addChild(wrapper); } ……… // 持续设置wrapper的servlet属性 wrapper.setServletClass(servlet.getClass().getName()); wrapper.setServlet(servlet); …… // 构建 ApplicationServletRegistration返回 ServletRegistration.Dynamic registration = new ApplicationServletRegistration(wrapper, context); return registration; }啰啰嗦嗦了半天，一句话概括就是：把servlet注册到context里 ...

关于tomcat:Tomcat体系结构

Tomcat的体系结构1.Tomcat是实现了Servlet标准的web容器,可能解决http/https协定2.Tomcat由多个组件形成,Server,Service,Engine,Connector,Host,Context,不同组件负责不同的性能3.Tomcat通过Catalina将server.xml解析并实例化Server实例4.一个Server实例蕴含多个Service容器实例,Service由多个连接器Connector和一个Engine形成5.Connector负责解决客户端发动的申请协定，Connector将连贯信息封装成为Request申请对象和Response响应对象，并通过适配器Adaptor转换成容器能够解决的对象6.Connector与Engine容器进行通信,一个Engine容器由多个Host虚拟主机对象形成7.每个Host中能够配置多个Context对象,即部署多个我的项目。8.一个Context蕴含多个Wrapper通过解析web.xml将Servlet封装到Wrapper容器中。8.浏览器收回的申请信息,通过Mapper映射器找到对应的Wrapper容器,并将定义的filter一起组成FilterChain执行Servlet中的Service办法,最初将信息封装成Response返回给客户端

关于tomcat:深入源码了解-Tomcat-的构造

Tomcat外部原理Tomcat 大家始终都在用，也用了好多年了，然而 Tomcat 到底是啥，外部是咋样的，不晓得~来，我从源码角度，给大家揭开它的面纱~ 1. Tomcat架构这个是tomcat的架构图，专治密集恐惧症患者~~虚线的代表同一多个Server：代表一个运行的tomcat实例，蕴含一个或多个service子容器Service: 代表tomcat中一组解决申请，提供服务的组件，蕴含多个Connector和一个ContainerConnector: 在指定IP、端口、协定下监听客户端申请，创立Request 、Response 给 Engine，从Engine取得响应给客户端。Connector是通过ProtocolHandler 来解决申请的，ProtocolHandler蕴含三个部件：Endpoint、Processor、Adapter Endpoint: 解决底层socket 网络连接。Acceptor 监听申请，Handler解决接管到的socket, AsyncTimeout 查看异步Request的超时Processor: 将Endpoint 接管到的Socket 封装成RequestAdapter: 将Request 交给Container 解决Container: 容器的父接口，用于封装和治理 Servlet，采纳责任链设计模式，蕴含四个组件 Engine: 可运行的servlet 引擎实例，一个服务中只有一个。次要性能是将申请委托给适当虚拟主机解决。Host: Engine的子容器，一个Host代表一个虚拟主机，一个虚拟主机能够部署一个或多个Web App，每个Web App对应一个ContextContext: 代表Servlet 的Context，是Servlet的根本运行环境，示意web利用自身。它最重要性能是治理外面的servletWrapper: 示意一个独自的Servlet，是Context的子容器，也是最底层的容器，没有子容器了。治理 Servlet的装载、初始化、执行和资源回收2. Tomcat源码咱们来追踪 SpringBoot启动过程，看一下它是怎么创立Tomcat的。跟到 ServletWebServerApplicationContext#refresh()办法，如图：点开 createWebServer()办法：进入TomcatServletWebServerFactory#getWebServer(): 一步步来看tomcat的构建过程。设置运行门路 File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");tomcat.setBaseDir(baseDir.getAbsolutePath());增加 Connector Connector connector = new Connector(this.protocol);connector.setThrowOnFailure(true);tomcat.getService().addConnector(connector);先点getService()进去看下： public Service getService() { return getServer().findServices()[0];}再点getServer()看看： ...

关于tomcat:Tomcat技术原理浅析

前言依照常规，厘清利用之间的关系，使学习自身造成一个体系框架。Tomcat、常见的一个Web应用服务器(临时以此称说，下文会有分类辨析)，旨在总结学习过程中的重点，相应常识不清晰时能够有一个绝对清朗的概念，底层原理倡议从专业书籍中获取。辨析Web服务器、应用程序服务器与Web容器随着技术的逐步倒退，各个服务器的性能都在逐步扩大，界线也越来越含糊，以至于初听到这些名词的时候，感觉不能了解。最好的了解应该是在特定的利用场景下对具体的技术深刻理解，而后再做体系的学习。先介绍三个概念，再简略对服务器作一个划分。 Web服务器：基本功能是提供Web信息浏览服务，存储、解决和传递网页给客户端，应用HTTP协定进行传输，不波及非动态资源的获取。其波及到的功能模块次要如下： TCP监听模块：服务器监听某个端口（个别是8080端口），以建设与客户端之间的连贯预处理：此处次要做三件事：1. 从TCP报文中获取HTTP申请报文。 2. 依据和用户代理的协商进行解密，解压，平安解决等。3. 依据服务器本身的配置进行平安解决，建设会话状态等URI路由：解析URL字符串和动作以确定用户代理申请的资源，依据匹配规定（通常依据正则表达式+后缀）路由到动态资源解决模块或动静资源解决模块动态资源解决模块：负责找到动态资源，比方HTML/Javascript/CSS文件/图片/图像，确定内容是字符流或者字节流，并确定对应MIME,比方HTML生成MIME为text/html的字符流，mpeg视频文件生成MIME为video/mpeg的字节流动静资源解决模块：运行业务解决逻辑，我了解是调用其余程序对应的服务解决信息。后处理：依据和客户端协商的协定进行加密，压缩，平安解决等资源输出模块：把解决好的内容和类型封装成HTTP报文，发送到TCP连贯的另一端应用程序服务器：作为应用程序服务器，它通过各种协定（包含HTTP协定），把商业逻辑裸露给(expose)客户端应用程序。Web服务器次要是解决向浏览器发送HTML以供浏览，而应用程序服务器提供拜访商业逻辑的路径以供客户端应用程序应用。应用程序应用此商业逻辑就象你调用对象的一个办法(或过程语言中的一个函数)一样。在大多数情景下，应用程序服务器是通过组件(component)的利用程序接口(API)把商业逻辑裸露(expose)(给客户端应用程序)的，例如基于J2EE(Java 2 Platform， Enterprise Edition)应用程序服务器的EJB(Enterprise JavaBean)组件模型。此外，应用程序服务器能够治理本人的资源，例如看大门的工作(gate-keeping duties)包含平安(security)，事务处理(transaction processing)，资源池(resource pooling)，和音讯(messaging)。就象Web服务器一样，应用程序服务器配置了多种可扩大(scalability)和容错(fault tolerance)技术。 Web容器：能够了解为加强Web服务器动静获取资源的能力，以下是代表性的动静获取资源技术：技术名词特点CGI 专用网关接口以独立过程运行，能够用多种语言开发，比方C,C++,VB,Perl，灵便但效率低，保护简单PHP服务器端嵌入HTML脚本，开源，功能强大，扩展性较差JSP服务器端嵌入HTML脚本，跨平台，部署前需编译，次要毛病是编写JSP比较复杂，需相熟JAVA及相干技术ASP服务器端嵌入HTML脚本，开发简略，功能强大，只能在windows下运行开发一个Web程序开发框架，蕴含运行环境（比方解释执行JSP、Php等），解决鲁捧性、可靠性，提供疾速开发接口，开发人员专一于业务实现，框架也提供定制和扩大，这个框架也称为Web容器。相比拟于，减少的次要功能模块为：调配线程池资源：容器为每个申请调配一个线程进行解决，通常采取线程池的形式高效理由CPU算资源封装Request/Response上下文：一个申请对应一个上下文，Request申请包含URL、Http申请、以及构建的Session、Cookie等对象URl路由动静资源解决模块：比方Java的Servlet回收资源：回收线程资源，个别都以线程池形式实现，所以将线程返回线程池一些支流服务器名词Web服务器Web容器应用程序服务器反向代理反对IIS✅✅ ✅Nginx✅ ✅Apache✅ ✅Tomcat✅✅✅ Jetty✅✅✅ WebSphere✅✅✅ WebLogic✅✅✅ 能够见到 Web服务器：IIS、Nginx、Apache 应用程序服务器：WebSphere、WebLogic 至于Tomcat、Jetty，其提供了动态资源服务器的性能，也扩大了应用程序服务器的一些性能。所以其个别称为Web容器，也有叫做轻量级应用程序服务器，其余叫法依我看是不太精确的。还有一个观点，既然Tomcat蕴含了动态服务器的性能，兼具应用程序服务器的某些个性，那只用Tomcat、Jetty就行了？？emmm模棱两可，实际上个别在Tomcat这些Web容器前流量会走一层Nginx做代理，同时解决动态资源。最初赘述一点，Jetty与Tomcat同为ServletWeb容器，次要解决HTTP；Netty是一个高性能、异步事件驱动的 NIO 框架，它提供了对 TCP、UDP 和文件传输的反对。 Tomcat底层Tomcat的架构核心内容是Connector和Container组件一个Server服务器中可能有多个Service，Service能够临时了解为“服务”。Server负责管理Service的生命周期，让外界可能拜访，Service将Connector和Container分割在一起。 Connector：负责创立Request和Response对象 Container EngineHost：虚拟主机Context：所属Web利用的上下文Wrapper：针对每一个具体的Servlet本想着具体介绍一点，这部分材料很多，不仅反复且不迭别人优良，能够联合Tomcat的配置文件了解一下其架构。

关于tomcat:锁屏面试题百日百刷tomcat优化相关

锁屏面试题百日百刷，每个工作日保持更新面试题。锁屏面试题app、小程序现已上线，官网地址：https://www.demosoftware.cc/#/introductionPage。已收录了每日更新的面试题的所有内容，还蕴含特色的解锁屏幕温习面试题、每日编程题目邮件推送等性能。让你在面试中后人一步，吊打面试官!接下来的是今日的面试题： ====tomcat优化教训？优化连贯配置.这里以tomcat7的参数配置为例，须要批改conf/server.xml文件，批改连接数，敞开客户端dns查问。参数解释： URIEncoding=”UTF-8″ :使得tomcat能够解析含有中文名的文件的url，真不便，不像apache里还有搞个mod_encoding，还要手工编译 maxSpareThreads : 如果闲暇状态的线程数多于设置的数目，则将这些线程停止，缩小这个池中的线程总数。minSpareThreads : 最小备用线程数，tomcat启动时的初始化的线程数。 enableLookups : 这个效用和Apache中的HostnameLookups一样，设为敞开。 connectionTimeout : connectionTimeout为网络连接超时工夫毫秒数。 maxThreads : maxThreads Tomcat应用线程来解决接管的每个申请。这个值示意Tomcat可创立的最大的线程数，即最大并发数。 acceptCount : acceptCount是当线程数达到maxThreads后，后续申请会被放入一个期待队列，这个 acceptCount是这个队列的大小，如果这个队列也满了，就间接refuse connection maxProcessors与minProcessors : 在 Java中线程是程序运行时的门路，是在一个程序中与其它管制线程无关的、可能独立运行的代码段。它们共享雷同的地址空间。多线程帮忙程序员写出CPU最大利用率的高效程序，使闲暇工夫放弃最低，从而承受更多的申请。通常Windows是1000个左右，Linux是2000个左右。 useURIValidationHack: 咱们来看一下tomcat中的一段源码：【security】 if (connector.getUseURIValidationHack()) { String uri = validate(request.getRequestURI()); if (uri == null) { res.setStatus(400); res.setMessage(“Invalid URI”);throw new IOException(“Invalid URI”); } else { req.requestURI().setString(uri); // Redoing the URI decoding req.decodedURI().duplicate(req.requestURI()); req.getURLDecoder().convert(req.decodedURI(), true); 能够看到如果把useURIValidationHack设成”false”，能够缩小它对一些url的不必要的查看从而减省开销。enableLookups=”false” ：为了打消DNS查问对性能的影响咱们能够敞开DNS查问，形式是批改 server.xml文件中的enableLookups参数值。 disableUploadTimeout ：相似于Apache中的keeyalive一样给Tomcat配置gzip压缩(HTTP压缩)性能 compression=”on” compressionMinSize=”2048″ compressableMimeType=”text/html,text/xml,text/JavaScript,text/css,text/plain” HTTP 压缩能够大大提高浏览网站的速度，它的原理是，在客户端申请网页后，从服务器端将网页文件压缩，再下载到客户端，由客户端的浏览器负责解压缩并浏览。绝对于一般的浏览过程HTML,CSS,javascript , Text ，它能够节俭40%左右的流量。更为重要的是，它能够对动静生成的，包含CGI、PHP , JSP , ASP , Servlet,SHTML等输入的网页也能进行压缩，压缩效率惊人。 1)compression=”on” 关上压缩性能 2)compressionMinSize=”2048″ 启用压缩的输入内容大小，这外面默认为2KB 3)noCompressionUserAgents=”gozilla, traviata” 对于以下的浏览器，不启用压缩 4)compressableMimeType=”text/html,text/xml” 压缩类型最初不要忘了把8443端口的中央也加上同样的配置，因为如果咱们走https协定的话，咱们将会用到8443端口这个段的配置:<!–enable tomcat ssl–> <Connector port=”8443″ protocol=”HTTP/1.1″ URIEncoding=”UTF-8″ minSpareThreads=”25″ maxSpareThreads=”75″ enableLookups=”false” disableUploadTimeout=”true” connectionTimeout=”20000″ acceptCount=”300″ maxThreads=”300″ maxProcessors=”1000″ minProcessors=”5″ useURIValidationHack=”false” compression=”on” compressionMinSize=”2048″ compressableMimeType=”text/html,text/xml,text/javascript,text/css,text/plain”SSLEnabled=”true” scheme=”https” secure=”true” clientAuth=”false” sslProtocol=”TLS” keystoreFile=”d:/tomcat2/conf/shnlap93.jks” keystorePass=”aaaaaa”/> ...

关于tomcat:Tomcat端口地址已在使用-Bind-failed

环境 Linux/Ubuntu20.04LTSIntelliJ IDEA Community Editon 2021.1java-11-openjdk-amd64apache-tomcat-7.0.109异样 tomcat服务端口被占用！重大: Failed to initialize end point associated with ProtocolHandler ["http-bio-8087"]java.net.BindException: 地址已在应用 (Bind failed) <null>:80877月 14, 2021 9:45:36 下午 org.apache.catalina.core.StandardServer await重大: StandardServer.await: create[localhost:8005]: 起因端口地址已在应用，端口地址抵触上次运行服务没有及时敞开，服务仍在运行，故造成端口抵触计划端口抵触，间接批改配置文件里的端口号后，从新运行我的项目服务未及时敞开造成，敞开上次运行的服务，关上tomcat目录所在文件，间接敞开服务,执行 $ ./shutdown.shlauiji@lauiji-IdeaPad-15sIML-2020:/usr/local/apache-tomcat-7.0.109/bin$ ./shutdown.sh从新运行我的项目即可阐明【遇上旱季，吃定彩虹】 --Layuji由集体整顿公布，编写过程不免有所脱漏或谬误，恳请指出，免得误导大家！

关于tomcat:Tomcat-基础及配置

一、原理1. 浏览器拜访服务器流程用户输出申请到浏览器浏览器发送TCP连贯申请服务器接管到（疏忽Nginx等状况）申请并三次握手建设连贯浏览器生成HTTP的数据包并发送服务器收到并解析服务器执行申请并封装后果发送浏览器收到HTTP格局数据包并解析渲染2. Tomcat申请解决流程首先，Tomcat是一个HTTP服务器 Tomcat中的HTTP服务器（Connectot组件）在接管到申请之后把申请交给Servlet容器（Conntainer组件）来解决（解耦），Servlet容器通过Servlet接口调用业务类，Servlet容器这一套内容叫做Servlet标准 3. Servlet容器解决流程HTTP服务器把申请信息应用ServletRequest对象封装依据配置，找到url和Servlet的映射，调用Servlet容器中的某个具体Servlet如果Servlet还没有加载，就用反射机制创立这个Servlet，并调用Servlet的init办法来实现初始化调用这个Servlet的service办法解决申请，处理结果用ServletResponse对象封装ServletResponse 对象返回给HTTP服务器，HTTP服务器把响应发给客户端二、组件1. 连接器组件Coyote客户端通过Coyote与服务器建设连贯，发送并响应申请 Coyote 封装底层网络通信（Socket申请及响应解决）Coyote 使 Catalina容器（容器组件）与具体的申请及I/O操作解耦Coyote 将Socket 输出封装Request对象，容器解决后，Catelina通过Response对象将后果写入输入流Coyote 去负责具体应用层协定和传输层io相干内容 ### 2. Servlet 容器 Catalina Tomcat由一系列可配置（server.xml）的组件形成的web容器，Catalina是它的Servlet容器。某种方面说，Tomcat就是一个Servlet容器，Catalina是它的外围组件。三、外围配置配置文件server.xml <?xml version="1.0" encoding="UTF-8"?><Server port="8005" shutdown="SHUTDOWN">   <Listener className="org.apache.catalina.startup.VersionLoggerListener" />  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />  <GlobalNamingResources>  <Resource name="UserDatabase" auth="Container" type="org.apache.catalina.UserDatabase" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" pathname="conf/tomcat-users.xml" /> </GlobalNamingResources>  <Service name="Catalina">    <Executor name="commonThreadPool" namePrefix="thread-exec-" maxThreads="200" minSpareThreads="100" maxIdleTime="60000" maxQueueSize="Integer.MAX_VALUE" prestartminSpareThreads="false" threadPriority="5" className="org.apache.catalina.core.StandardThreadExecutor" />    <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" /> <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />       <Engine name="Catalina" defaultHost="localhost">    <Realm className="org.apache.catalina.realm.LockOutRealm">  <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase"/> </Realm>   <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">  <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log" suffix=".txt" pattern="%h %l %u %t "%r" %s %b" /> </Host>  <Host name="www.abc.com" appBase="webapps1" unpackWARs="true" autoDeploy="true">  <Context docBase="/Users/yingdian/web_demo" path="/web3"></Context>  <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log" suffix=".txt" pattern="%h %l %u %t "%r" %s %b" /> </Host> </Engine> </Service></Server>

关于tomcat:解决-无法启动组件StandardEngineCatalinaStandardHostlocalhost

前言最近在搭建环境,发现每个工程启动基本上都会报这个谬误看了一下大略意思就是指定了一个filter 而后呢并没有找到这个filter的类信息不影响工程的失常运行,改bug之余明天跟进了一下终于解决了: 首先找到/usr/local/oneaccess/bim/tomcat/webapps/manager/WEB-INF/(请对号入座这是我线上的地址) 找到web.xml文件编辑之: 搜寻报错信息中提醒的filter的名称 csrf 发现csrf对应的filter信息被正文了间接把正文的内容放开或者把这两段信息都删掉即可相干材料web.xml文件详解

关于tomcat:centos7中tomcat的systemctl启动方式启动停止重启开机启动

指标：在centos7中配置tomcat的systemctl启动形式（启动、进行、重启、开机启动）剖析：1.解压文件；2.挪动解压文件至 /usr/local/下，并改名tomcat;3.配置startup.sh、shutdown.sh、catalina.sh 环境；4.配置启动脚本tomcat.service ；5.设置脚本开机启动；6.测试。操作流程：源码装置 #解压源码tar zxvf apache-tomcat-8.5.23.tar.gz #文件到挪动/usr/local/下，并改名tomcatmv apache-tomcat-8.5.23 /usr/local/tomcat配置文件配置:将以下内容增加到startup.sh、shutdown.sh、catalina.sh 当中留神批改你的java门路 export JAVA_HOME=/usr/local/java #jdk门路export TOMCAT_HOME=/usr/local/tomcat #tomcat门路export CATALINA_HOME=/usr/local/tomcat #tomcat门路export CLASS_PATH=$JAVA_HOME/bin/lib:$JAVA_HOME/jre/lib:$JAVA_HOME/lib/tool.jarexport PATH=$PATH:/usr/local/java/bin:/usr/local/tomcat/bin开机启动设置1.进入/lib/systemd/systemcd /lib/systemd/system2.创立tomcat.servicevi /lib/systemd/system/tomcat.service3.tomcat.service中增加配置信息 [Unit]Description=tomcatAfter=network.target [Service]Type=oneshotExecStart=/usr/local/tomcat/bin/startup.shExecStop=/usr/local/tomcat/bin/shutdown.shExecReload=/bin/kill -s HUP $MAINPIDRemainAfterExit=yes [Install]WantedBy=multi-user.target保留退出 systemctl enable tomcat.service （设置开机自启动）4.操作命令 systemctl status tomcat.service （查看服务以后状态）systemctl start tomcat.service　（启动tomcat服务）systemctl stop tomcat.service　（进行tomcat服务）systemctl restart tomcat.service　（重新启动服务）systemctl reload tomcat.service （从新加载配置）systemctl enable tomcat.service （设置开机自启动）systemctl disable tomcat.service （进行开机自启动）systemctl list-units --type=service （查看所有已启动的服务）例：查看服务启动状态（已启动状态）例：Tomcat 拜访页面测试地址：http://192.168.157.130:8080/ 5.参考命令 systemctl start *.service #启动服务systemctl stop *.service #进行服务systemctl restart *.service #重启服务systemctl reload *.service #从新加载服务配置文件systemctl status *.service #查问服务运行状态systemctl enable *.service #开机运行服务systemctl disable *.service #勾销开机运行systemctl --failed #显示启动失败的服务systemctl is-enabled servicename.service #查问服务是否开机启动

关于tomcat:Tomcat安装配置

Tomcat下载Tomcat下载地址个别不下载新进去的版本，下载较为稳固的版本比拟好，我这里下载Tomcat 9 点击右边download下的tomcat 9进入下载页面 Mirros能够更换镜像源，如果太慢能够换一个，然而文件自身不大，就10多MCore 中抉择相应的版本即可，64为windows就抉择 64bit-Windows zip即可，tar为linux版本Source Code 上面还有源码文件另外，download上面还有archive（文档），外面有各个版本的目录，进入bin目录下载即可而后下载解压到指定目录即可 Tomcat配置tomcat 由java编写，须要jvm运行，所以须要配置JDK，如果不配置好上面的环境，会闪退新建零碎变量JAVA_HOME --------> 你的jdk装置目录（如：D:\DevEvironment\openjdk-11.0.2）点击path，新建输出：%JAVA_HOME%/bin 开启：而后进入tomcat 9解压目录下的bin目录，点击startup.bat批处理文件，呈现启动工夫，即可开启tomcat 进入浏览器输出：http://localhost:8080 或 http://127.0.0.1:8080进行关上... 敞开：间接点击控制台敞开即可，或者进入bin目录，点击shutdown.dat 另外控制台乱码状况点击控制台标题栏、属性，能够看到是GBK编码，而tomcat控制台为UTF-8编码，所以会呈现乱码你能够抉择去注册表更改控制台的编码，也能够去改tomcat的编码方式这我采纳更改tomcat编码：进入tomcat装置目录/conf/logging.properties，用记事本关上，ctrl + f 搜寻java.util.logging.ConsoleHandler.encoding = UTF-8 ,更改为GBK编码即可，再重新启动tomcat Tomcat 目录介绍bin 次要寄存二进制可执行文件和脚本。conf 次要寄存各种配置文件。lib 次要用来寄存Tomcat运行须要加载的jar包。logs 次要寄存Tomcat在运行过程中产生的日志文件。temp 次要寄存Tomcat在运行过程中产生的临时文件。webapps 次要寄存应用程序，当Tomcat启动时会去加载该目录下的应用程序。work 次要寄存tomcat在运行时的编译后文件，例如JSP编译后的文件。-------后续再更新-----

关于tomcat:Tomcat源码学习第4篇-Servlet请求分析

前段时间家里有事忙，停更了好长一段时间，这里跟期待更新的小伙伴们说一声道歉，没能提前阐明一下，让小伙伴们等了这么久，真的不好意思！后面说完了Tomcat的初始化和启动步骤，那么接下来就要进入重头戏了！在本篇文章中，我会跟后面一样，通过图文的形式来带着小伙伴们理解一个 Servlet是如何被tomcat解决的，具体的解决链路都有哪些。一、申请剖析在《Tomcat源码学习第2篇》中备注了各个组件的阐明。当一个servlet申请到来的时候，首先通过的是connector组件，它是用来接管申请的。该组件接管到申请之后，会把相干申请进行封装，而后传递到engine组件中。紧跟着，engine组件会锁定对应的host，context以及wrapper，一层层的传递上来，找到最终解决申请的servlet实例。二、深刻摸索不晓得大家还有没有印象，在后面的文章中，咱们在NioEndpoint类中，启动Accepter线程的入口处上方还有着一个线程组在启动运行，然而却没有解说该线程是用来干嘛的~ NioEndpoint.startInternal() 点击跳转到该类过去，咱们能够看到他实现了Runnable接口，那么咱们间接查看他的run()办法，看看它的运行逻辑。 Poller.run() 通过正文咱们能够晓得，该线程次要用于轮询已连贯的套接字，查看是否触发了事件，并在事件产生时将关联的套接字移交给对应的处理器。在源码中咱们能够看到keyCount变量记录着待处理申请数，提供给前面做相应判断。持续往下走，通过keyCount判断是否有申请须要进行解决，需要的话则通过selector.selectedKeys()拿到须要被解决的channel汇合，进行循环解决。在while循环中咱们看到，所有就绪的通道都调用的是processKey(sk, socketWrapper)办法进行解决。点击跳转过来该办法，在这里能够看到他对该sk做了读写判断，既然是申请进来，那必定是做读操作，咱们先进读相干的办法看一下。 NioEndpoint.processKey() 进来之后咱们能够看到它首先在缓存池中尝试去获取一个解决线程，当缓存池中没有线程时，就创立一个新的线程，如果有的话就间接应用。 AbstractEndpoint.processSocket() 既然是线程了，那么咱们就关怀线程的外围办法即可。点击SocketProcessorBase跳转查看run()办法。 SocketProcessorBase.run() 在doRun()处打上断点，单击下一步，跳转到NioEndpoint.doRun()办法中。Poller线程移交到这边的线程进行解决，在该线程中须要失去以后的socket，做进一步的解决。进入该办法之后，咱们能够看到它首先对wrapper进行判断，不为空再取出socket，而后尝试着在connections中去获取对应的processor，如果获取不到，再尝试获取曾经解决过连贯，然而尚未销毁的processor中去获取，还获取不到才进行创立。这样能够防止频繁的创立和销毁对象。 AbstractProtocol.process() 失去processor之后，调用process办法对报文进行解析。进入该办法之后，咱们能够看到这外面是对socketEvent的状态进行判断，咱们以后申请次要是读状态，在此处打上断点，跳到该办法进来看一下。 AbstractProcessorLight.process() 这里咱们能够看到是进入到了 http11类中，在该类外面对报文进行解析，封装原生的request和response对象。这里的response因为咱们还没有到返回的步骤，所以只是做个初步的参数设置。后续要传入Adapter进行下一步操作。 Http11Processor.service() 在这里对原生的request和response进行转换，失去HttpServletRequest和HttpServletResponse。而后依据申请信息找到可能解决以后申请的host，context，wrapper。 CoyoteAdapter.service() 在这办法能够看到它会通过getMapper()办法去匹配可能解决以后申请的 host,context,wrapper。到这里可能有的小伙伴会奇怪，为什么是从mapper中去匹配呢？这个问题留给你们去摸索一下，等下篇再给你们解答。 CoyoteAdapter.postParseRequest() 上一办法中，通过connector获取service之后再获得对应的mapper，可是进来之后却没有看到对该mapper对象的构建，那该对象是哪里来的呢？ Mapper.map() 不晓得大家还记不记得在第二篇中，在StandardService类中initInternal()和startInternal()办法中有mapperListener办法的初始化和启动。在该办法中查找到对应的host, context, wrapper。 Mapper.internalMap() 回到CoyoteAdapter.postParseRequest()，通过Evaluste咱们能够看到以后申请对应的host, context, wrapper以及实例的映射均已找到。接下来要做的就是依据链路组件进行一级级的调用，直至最初取出servlet执行。 CoyoteAdapter.service() 先失去host，在通过host持续调用下一级组件 StandardEngineValve.invoke() AbstractAccessLogValve.invoke() ErrorReportValve.invoke() 这里拿到context，持续invoke()。 StandardHostValve.invoke() AuthenticatorBase.invoke() StandardContextValve.invoke() 拿到wrapper之后，持续向下执行，从wrapper容器中失去servlet对象。 StandardWrapperValve.invoke() ...

关于docker:使用-Docker-运行-Tomcat-容器

# 搜寻tomcat镜像docker search tomcat# 拉取tomcat镜像docker pull tomcat# 查看所有镜像docker images# 运行nginx容器，-d 后盾运行容器并打印出容器ID，-p 将容器的8080端口映射到主机的3355端口docker run -d -p 3355:8080 --name tomcat01 tomcat# 进入容器docker exec -it tomcat01 /bin/bash# 进入容器拷贝文件cd /usr/local/tomcat/cp -r webapps.dist/* webapps/exit在浏览器中拜访并显示 tomcat 的默认页： http://localhost:3355查看所有运行中的容器： docker ps通过容器名称进行容器： docker container stop tomcat01通过容器名称移除容器： docker container rm tomcat01

关于tomcat:安装配置Tomcat

下载，装置配置Tomcat1.下载下载地址：http://tomcat.apache.org/依据本人的电脑抉择32位或者64位能够下载免安装版(zip)，或者安装版(.exe)2.装置如果下载免安装版，下载后间接解压即可启动：找到bin目录下的startup.bat，点击启动tomcat敞开：找到bin目录下的shutdown.bat，点击敞开tomcat3.配置配置环境变量1.右下角搜寻环境变量2.点击环境变量 3.在零碎变量中增加一条新的变量变量名为TOMCAT_HOME变量值为Tomcat装置目录 4.在path变量中增加新的值值为%TOMCAT_HOME%\bin4.测试是否装置胜利 1.启动Tomcat2.关上浏览器键入 http://localhost:8080 进入如下页面则示意装置胜利。注：如果启动tomcat时呈现闪退 1.在命令行下启动Tomcat,会显示失败起因，个别是没有配置JAVA_HOME和JRE_HOME两个环境变量cd 是切换文件夹 2.配置JAVA_HOME和JRE_HOME （1）.首先在零碎变量中增加JAVA_HOME 变量名为JAVA_HOME，变量值为jdk的装置门路命令行下输出java -version能够查看是否装置jdk 输出java -verbose能够查看jre装置门路默认门路为 C:\Program Files\Java\jre1.8.0_241 (2).增加JRE_HOME

关于tomcat:IDEA里Tomcat-Console日志中文乱码问题解决

IDEA内Tomcat中文乱码Ctrl+Alt+S关上设置，而后Editor->File Encodings，将圈出的都改成UTF-8 IDEA菜单->help->Edit Custom VM Options，最初一行增加-Dfile.encoding=UTF-8 重启Tomcat后失效，发现Console日志外面都是失常的中文了，如果没失效，请重启IDEA，多期待一会，才会失效

关于centos7:CentOS7安装tomcat

1 查看tomcat状态如果没有tomcat会报错。 systemctl status tomcat.service//或者 systemctl status tomcat2 装置tomcat腾讯云的镜像没有tomcat，须要手动下载，我选的第二种计划。 yum install tomcat//或者 -y代表所有的询问都选yyum -y install tomcattomcat的装置目录在 /usr/share/tomcat，能够cd进去查看是否有文件。 3 启动tomcatsystemctl start tomcat.service//或者 systemctl start tomcat此时，cd到tomcat 的 webapps 目录，用ls查看目录之后会发现是空的，这证实须要装置tomcat的治理界面。 4 装置tomcat的治理界面yum install tomcat-webapps tomcat-admin-webapps5 增加用户回到 tomcat 装置目录（/usr/share/tomcat），进入 conf 目录，关上 tomcat-users.xml 文件，在 <tomcat-users> 标签下，增加如下配置：（username和password最好简单！！！） <role rolename="manager-gui"/><user username="root" password="root" roles="manager-gui"/>6 重启服务。systemctl restart tomcat.service//或者 systemctl restart tomcat7 tomcat其余重要命令进行 tomcat 服务 systemctl stop tomcat.service//或者 systemctl stop tomcat开机自启动 tomcat systemctl enable tomcat

关于tomcat:tomcat8-日志路径乱码自动分割-问题解决

日志乱码vim catalina.sh在如图所示处增加 -Dfile.encoding=UTF-8JAVA_OPTS="$JAVA_OPTS -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dfile.encoding=UTF-8" 日志门路vim catalina.sh在如图所示批改 CATALINA_OUT=if [ -z "$CATALINA_OUT" ] ; then #CATALINA_OUT="$CATALINA_BASE"/logs/catalina.out CATALINA_OUT=/data/WEBLOG/uat-ecommerce-app/catalina.outfi日志主动宰割[root@tomcat-uata_20 conf]# vim logging.properties1catalina.org.apache.juli.AsyncFileHandler.level = FINE1catalina.org.apache.juli.AsyncFileHandler.directory = /data/WEBLOG/uat-ecommerce-app1catalina.org.apache.juli.AsyncFileHandler.prefix = catalina.1catalina.org.apache.juli.AsyncFileHandler.encoding = UTF-82localhost.org.apache.juli.AsyncFileHandler.level = FINE2localhost.org.apache.juli.AsyncFileHandler.directory = /data/WEBLOG/uat-ecommerce-app2localhost.org.apache.juli.AsyncFileHandler.prefix = localhost.2localhost.org.apache.juli.AsyncFileHandler.encoding = UTF-83manager.org.apache.juli.AsyncFileHandler.level = FINE3manager.org.apache.juli.AsyncFileHandler.directory = /data/WEBLOG/uat-ecommerce-app3manager.org.apache.juli.AsyncFileHandler.prefix = manager.3manager.org.apache.juli.AsyncFileHandler.encoding = UTF-84host-manager.org.apache.juli.AsyncFileHandler.level = FINE4host-manager.org.apache.juli.AsyncFileHandler.directory = /data/WEBLOG/uat-ecommerce-app4host-manager.org.apache.juli.AsyncFileHandler.prefix = host-manager.4host-manager.org.apache.juli.AsyncFileHandler.encoding = UTF-8java.util.logging.ConsoleHandler.level = FINEjava.util.logging.ConsoleHandler.formatter = org.apache.juli.OneLineFormatterjava.util.logging.ConsoleHandler.encoding = UTF-8

关于tomcat:DEBUG系列Windows上Tomcat日志乱码

1. 产生乱码起因Windows上idea+tomcat乱码问题的根本原因，编码字符集不一样。乱码日志产生过程：tomcat依照某种字符集编码产生日志文件，给IDEA，依照某种字符集解析，展现在本人的控制台里;windows上的IDEA，在本人的控制台展现日志默认应用操作系统GBK的编码格局。Tomcat的各种日志文件绝大多数默认是UTF-8;将他们的编码格局设置对立即可，GBK是国家标准，UTF-8是国内编码。对立设置成UTF-8通用性更好。2. 解决方案设置IDEA控制台显示日志时所用的字符集 Help->Edit Costum Vm Option ->增加一行 -Dfile.encoding=UTF-8 重启失效。/tomcat/conf/logging.properties，该文件配置tomcat日志编码格局。# 对应IDEA 中Srever中的日志编码格局，其余的各自对应。java.util.logging.ConsoleHandler.encoding = UTF-8

关于tomcat:Docker安装Tomcat

1、搜寻镜像 docker search tomcat2、下载镜像 docker pull tomcat3、查看镜像 docker images tomcat4、运行镜像 docker run -d -p 8080:8080 --name tomcat tomcat:latest5、拷贝镜像到须要映射的目录 docker cp tomcat:/usr/local/tomcat/conf /usr/app/tomcat/confdocker cp tomcat:/usr/local/tomcat/logs /usr/app/tomcat/logs6、应用映射的目录运行tomcat docker run -d -p 8080:8080 --name tomcat -v /usr/app/tomcat/webapps:/usr/local/tomcat/webapps -v /usr/app/tomcat/conf:/usr/local/tomcat/conf -v /usr/app/tomcat/logs:/usr/local/tomcat/logs --restart=always tomcat:latest

关于tomcat:IDEATomcat下http状态404的原因

从php转型java后刚接触tomcat就遇到了这个问题始终认为是tomcat配置呈现了问题重复调试重装了之后也没能解决然而黑框中startup后能够在浏览器失常拜访最初苦苦百度排查出居然是idea自带了个莫名其妙的欢送页面一样的货色他还找不到了!!!

关于tomcat:服务器Tomcat你会安装了吗

Tomcat 是一个合乎 JavaEE WEB 规范的最小的 WEB 容器，所有的 JSP 程序肯定要有 WEB 容器的反对能力运行，而且在给定的 WEB 容器外面都会反对事务处理操作。 Tomcat 是由 Apache 提供的（www.apache.org），能够用安装版和解压版，安装版能够在服务中呈现一 Tomcat 的服务，免装置没有，开发中应用免安装版。 Tomcat 简略的说就是一个运行 Java 的网络服务器，底层是 Socket 的一个程序，它也是 JSP 和 Servlet 的一个容器。Tomcat 是 Apache 软件基金会（Apache Software Foundation）的 Jakarta 我的项目中的一个外围我的项目，由 Apache、Sun和其余一些公司及集体共同开发而成。因为有了 Sun 的参加和反对，最新的 Servlet 和 JSP 标准总是能在 Tomcat 中失去体现。因为 Tomcat 技术先进、性能稳固，而且收费，因此深受 Java 爱好者的青睐并失去了局部软件开发商的认可，成为目前比拟风行的 Web 应用服务器。 Tomcat 服务器是一个收费的凋谢源代码的 Web 应用服务器，属于轻量级应用服务器，在中小型零碎和并发拜访用户不是很多的场合下被广泛应用，是开发和调试 JSP 程序的首选。对于一个初学者来说，能够这样认为，当在一台机器上配置好 Apache 服务器，可利用它响应 HTML（规范通用标记语言下的一个利用）页面的拜访申请。实际上 Tomcat 局部是 Apache 服务器的扩大，但它是独立运行的，所以当你运行 tomcat 时，它实际上作为一个与 Apache 独立的过程独自运行的。 ...

关于tomcat:使用Tomcat-Native提升Tomcat-IO效率

简介IO有很多种，从最开始的Block IO，到nonblocking IO，再到IO多路复用和异步IO，一步一步的将IO的性能晋升做到极致。明天咱们要介绍一下怎么应用Tomcat Native来晋升Tomcat IO的效率。 Tomcat的连贯形式Tomcat中应用连接器来解决与内部客户端的通信。Connecter次要用来承受内部客户端的申请，并转交给解决引擎解决。在Tomcat中有两种Connector。一种是 HTTP connector，一种是AJP connector。 HTTP connector大家应该很好了解，它也是tomcat默认应用的连接器。还有一个连接器叫做AJP，AJP次要是用来和web服务器进行通信用的，因为AJP协定的速度要比HTTP的快，所以AJP除了用来和其余webserver进行通信之外，还能够通过AJP来构建tomcat集群。这两种形式都反对4中协定，别离是BIO，NIO，NIO2和APR。 #以下四种Connector实现都是间接解决来自客户端Http申请org.apache.coyote.http11.Http11Protocol : 反对HTTP/1.1 协定的连接器。org.apache.coyote.http11.Http11NioProtocol : 反对HTTP/1.1 协定+New IO的连接器。org.apache.coyote.http11.Http11Nio2Protocol : 反对HTTP/1.1 协定+New IO2的连接器。org.apache.coyote.http11.Http11AprProtocol : 应用APR（Apache portable runtime)技术的连接器,利用Native#以下四种实现办法则是与web server打交道org.apache.coyote.ajp.AjpProtocol：应用AJP协定的连接器，实现与web server（如Apache httpd）之间的通信org.apache.coyote.ajp.AjpNioProtocol：SJP协定+ New IOorg.apache.coyote.ajp.AjpNio2Protocol：SJP协定+ New IO2org.apache.coyote.ajp.AjpAprProtocol：AJP + APR讲下他们的区别，BIO就是block IO是最最根底的IO形式，咱们通过这样来配置： <Connector port=”8080” protocol=”HTTP/1.1” maxThreads=”150” connectionTimeout=”20000” redirectPort=”8443” />Tomcat7以下版本在默认状况下是以bio模式运行的。自Tomcat 8.5 版本开始，Tomcat就移除了对BIO的反对。 New IO是基于java.nio包及其子包的一种IO形式。能提供非阻塞IO形式，比传统的BIO领有与更加高效的运行效率。咱们这样配置New IO: <Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol"connectionTimeout="20000"redirectPort="8443" />New IO和New IO2有什么区别呢？ New IO2是tomcat8中引入的IO形式，咱们能够这样配置： <Connector port="8080" protocol="org.apache.coyote.http11.Http11Nio2Protocol"connectionTimeout="20000"redirectPort="8443" />apr这种形式就高级了，这个是咱们明天要解说的tomcat native的次要作用。 APR和Tomcat Nativeapr的全称是Apache Portable Runtime，它是一个高度可移植的库，它是Apache HTTP Server 2.x的外围。 APR有许多用处，包含拜访高级IO性能（例如sendfile，epoll和OpenSSL），操作系统级别的性能（生成随机数，零碎状态等）和本机过程解决（共享内存，NT管道和Unix套接字）。 ...

关于tomcat:初学Tomcat遇到的一些问题

tomcat装置配置首先须要配置JAVA_HOME和JRE_HOME的环境变量，地址就是java根目录门路，如F:\Java在tomcat官网下载免安装版的压缩包。解压后dos窗口进入bin文件下，而后跑去服务startup如之后就会开启一个服务窗口能够拜访Tomcat根目录的webapps文件夹下的资源文件,首先在webapps文件夹下新建一个文件夹,名为Test,在Test文件夹下放入一个1.jpg的图片。浏览器拜访http://localhost:8080/Test/1.jpg,，就能够看到这张图片了。个别默认端口号时8080敞开服务就在dos窗口输出shutdown,服务窗口主动敞开。bin目录次要是用来寄存tomcat的命令，次要有两大类，一类是以.sh结尾的（linux命令），另一类是以.bat结尾的（windows命令）。 tomcat目录构造(参考网上)bin目录次要是用来批改环境变量，设置JDK门路、tomcat门路startup 用来启动tomcatshutdown 用来敞开tomcat批改catalina能够设置tomcat的内存 conf目录次要是用来寄存tomcat的一些配置文件server.xml能够设置端口号、设置域名或IP、默认加载的我的项目、申请编码web.xml能够设置tomcat反对的文件类型context.xml能够用来配置数据源之类的tomcat-users.xml用来配置管理tomcat的用户与权限在Catalina目录下能够设置默认加载的我的项目lib目录次要用来寄存tomcat运行须要加载的jar包例如，像连贯数据库的jdbc的包咱们能够退出到lib目录中来。logs目录用来寄存tomcat在运行过程中产生的日志文件在windows环境中，控制台的输入日志在catalina.xxxx-xx-xx.log文件中在linux环境中，控制台的输入日志在catalina.out文件中temp目录用户寄存tomcat在运行过程中产生的临时文件 webapps目录用来寄存应用程序当tomcat启动时会去加载webapps目录下的应用程序。能够以文件夹、war包、jar包的模式公布利用。当然，你也能够把应用程序搁置在磁盘的任意地位，在配置文件中映射好就行。work目录用来寄存tomcat在运行时的编译后文件例如JSP编译后的文件。清空work目录，而后重启tomcat，能够达到革除缓存的作用。 idea配置tomcat导航栏run->配置编辑增加新配置->抉择Tomcat Server->local写好名称，这里两个端口号主动生成，确认留神一旦端口号被占用，服务跑不起来会出错之后点击idea左下的绿色加号，run服务就跑起来了 tomcat服务run报错port out of range:-1解决办法：批改tomcat根目录的的conf文件夹下的server.xml，将<Server port="-1" shutdown="SHUTDOWN">改成<Server port="1-65535之间的任意一个整数" shutdown="SHUTDOWN">， tomcat乱码这就很烦。。。。解决办法：找到Tomcat根目录的conf文件夹下的logging.properties文件关上后在开端加上 java.util.logging.ConsoleHandler.encoding = GBK~~~~ok,胜利了！

关于tomcat:数据库连接池连接耗尽导致tomcat请求无响应呈现出假死状态

最艰难的事件就是意识本人！集体网站，欢送拜访！前言：最近，测试部门的共事找到我，说他们测试时，没一会就发现服务接口申请始终无响应，Tomcat跟死掉了一样，也没有返回任何的谬误响应，说让我连忙排查下；听完后，我霎时激灵了下，妹的，最近老是出问题，领导都要给我开批评大会了。哈哈，开玩笑的，像我这么英俊的人，领导怎么会忍心批评我呢，哼，我把这个问题马上解决掉，都不会让领导晓得的！简略说下程序部署状况：tomcat + oracle 排查过程：排查时，能够应用命令进行排查，也能够应用可视化监控工具；例如应用应用JDK自带的 jvisualvm.exe 监控工具。命令排查过程：1、申请服务无响应，首先看看tomcat是否是真的挂掉了：命令： ps -ef | grep tomcat 通过下面的命令查看tomcat运行着；执行后果如下：留神：如果此服务器中运行着多个tomcat，须要查看下图中画框的中央运行的tomcat地址是否正确；通过命令查看发现，tomcat失常运行着，那么这就是处于假死状态，上面接着排查。 2、查看http申请是否达到了tomcat：通过查看 tomcat 的 logs 目录下的 localhost_access_log 日志文件中申请记录；命令： tail -100f localhost_access_log 通过下面的命令查看实时的日志，执行完下面的查看日志的命令后，而后再次申请下程序，在日志中并没有发现申请记录，阐明tomcat处于一种假死状态，上面接着排查。 3、查看tomcat的JVM的GC状况：查看GC状况，是否因为频繁的GC，长时间的GC，导致程序呈现长时间的卡顿，最终导致申请来不及解决，进入队列中进行期待，调用方长时间得不到响应，造成tomcat假死状态；命令：jstat -gc pid time count 例如： jstat -gc 71129 1000 5 监控 71129 这个过程JVM的GC状况，每隔1000ms 输入一次，共输入5次；命令执行后果参数解析：通过下面命令查看GC状况，发现垃圾回收也不频繁，并且进行GC的工夫也不长，应该不是GC的起因。 4、查看tomcat的JVM的堆状况：查看堆内存的状况，是否存在堆内存溢出导致tomcat假死，无奈为新申请调配堆内存资源；命令： jmap -heap pid 例子： jmap -heap 71129 71129是正在运行tomcat的过程号；通过命令执行后果得悉，堆内存中可应用内存还很大，不会呈现内存溢出的问题，所以也不是堆内存过小导致的tomcat假死。 5、查看tomcat的 JVM线程状况：①、应用 jstack 命令导出以后JVM的线程dump快照，而后看看dump中线程都在干什么？ ...

关于tomcat:Tomcat的下载和配置

关于tomcat:tomcat的常规优化措施

1、调整jvm启动参数 JAVA_OPT="-server -Xms2g -Xmx2g -Xmn1g -XX:MetaspaceSize=512M XX:MaxMetaspaceSize=1024M -XX:+UseConcMarkSweepGC -XX:+UseCMSCompactAtFullCollection -XX:CMSInitiatingOccupancyFraction=80 -XX:+CMSParallelRemarkEnabled -XX:SoftRefLRUPolicyMSPerMB=0 -XX:+CMSClassUnloadingEnabled -XX:SurvivorRatio=8 -XX:+DisableExplicitGC -XX:-OmitStackTraceInFastThrow -XX:+HeapDumpOnOutOfMemoryError" 2、批改server.xml a.批改应用连接池形式 b.将默认的bio模式，批改成反对NIO的类型批改办法：将“HTTP/1.1”改为“org.apache.coyote.http11.Http11Nio2Protocol” c.tomcat日志级别将DEBUG改为INFO（tomcat日志级别没有ERROR） d.批改war包中的:/webapps/getway-server/WEB-INF/classes/logback.xml 日志级别为ERROR 补充：也可将运行形式改为APR模式，是在Tomcat上运行高并发利用的首选模式,能进一步提高性能，从操作系统层面解决异步的IO问题，对动态文件的解决能力也大幅提高，但配置较繁琐批改运行模式为apr的具体方法（所需的文件包详见tomcat-apr.zip）装置依赖库yum -y install gcc gcc-c++ libtool* autoconf automake expat-devel perl perl-devel 2、装置apr-1.6.5 [root@APR apr-1.6.5]# vim configure 默认值: 在第30392行 RM='$RM' 批改为: 在第30392行 RM='$RM -f' [root@APR apr-1.6.5]# ./configure --prefix=/usr/local/apr && make && make install 3、装置apr-iconv ./configure --prefix=/usr/local/apr-iconv --with-apr=/usr/local/apr && make && make install ...

关于tomcat:tomcat通过添加日志文件排查启动错误

问题启动报错 java.lang.NoClassDefFoundError: io/netty/util/concurrent/DefaultPromise$2 at io.netty.util.concurrent.DefaultPromise.notifyListeners(DefaultPromise.java:589) at io.netty.util.concurrent.DefaultPromise.setSuccess(DefaultPromise.java:397) at io.netty.util.concurrent.SingleThreadEventExecutor$2.run(SingleThreadEventExecutor.java:155) at io.netty.util.concurrent.DefaultThreadFactory$DefaultRunnableDecorator.run(DefaultThreadFactory.java:137) at java.lang.Thread.run(Unknown Source)这个不是真正的谬误，真正的谬误是其余谬误。因为日志不全，所以看不到，解决办法？增加日志文件。具体方法：https://juejin.im/post/686596... 真正的谬误 INFO: No Spring WebApplicationInitializer types detected on classpathSep 10, 2020 3:00:20 PM org.apache.catalina.core.StandardContext listenerStartSEVERE: Exception sending context initialized event to listener instance of class kalvan.log.logback.web.LogbackConfigListenerjava.lang.ClassCastException: org.slf4j.impl.Log4jLoggerFactory cannot be cast to ch.qos.logback.classic.LoggerContext //转换异样 at kalvan.log.logback.web.LogbackConfigListener.contextInitialized(LogbackConfigListener.java:103) at org.apache.catalina.core.StandardContext.listenerStart(StandardContext.java:4994) at org.apache.catalina.core.StandardContext.startInternal(StandardContext.java:5492) at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:150) at org.apache.catalina.core.ContainerBase.addChildInternal(ContainerBase.java:901) at org.apache.catalina.core.ContainerBase.addChild(ContainerBase.java:877) at org.apache.catalina.core.StandardHost.addChild(StandardHost.java:649) at org.apache.catalina.startup.HostConfig.deployWAR(HostConfig.java:1081) at org.apache.catalina.startup.HostConfig$DeployWar.run(HostConfig.java:1877) at java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source) at java.util.concurrent.FutureTask.run(Unknown Source) at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source) at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source) at java.lang.Thread.run(Unknown Source)Sep 10, 2020 3:00:20 PM org.apache.catalina.core.ApplicationContext logSLF4J: Class path contains multiple SLF4J bindings. //这里才是真正的谬误起因，即同一个类，有多个jar蕴含SLF4J: Found binding in [jar:file:/Users/gongzhihao/IdeaProjects-ys/qrcode/qrcode-server-pool/target/qrcode-server-pool-1.0.0-SNAPSHOT/WEB-INF/lib/activemq-all-5.8.0.jar!/org/slf4j/impl/StaticLoggerBinder.class] //排除这个jarSLF4J: Found binding in [jar:file:/Users/gongzhihao/IdeaProjects-ys/qrcode/qrcode-server-pool/target/qrcode-server-pool-1.0.0-SNAPSHOT/WEB-INF/lib/logback-classic-1.2.3.jar!/org/slf4j/impl/StaticLoggerBinder.class] //只保留这个jarSLF4J: Found binding in [jar:file:/Users/gongzhihao/IdeaProjects-ys/qrcode/qrcode-server-pool/target/qrcode-server-pool-1.0.0-SNAPSHOT/WEB-INF/lib/slf4j-jdk14-1.6.1.jar!/org/slf4j/impl/StaticLoggerBinder.class] //排除这个jarSLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory] //有3个，最终用这个解决办法：排除其余的，只留下一个。 ...

关于tomcat:tomcatSEVERE-Error-listenerStart和startup-failed-due

问题启动tomcat报错 org.apache.catalina.core.StandardContext startInternal SEVERE: Error listenerStart //报错org.apache.catalina.core.StandardContext startInternal SEVERE: Context [/******] startup failed due to previous errors //报错启动胜利报错 //实际上，在这之前，就曾经失败了启动失败，看到的报错，不是真正的谬误，实质谬误没有打印进去。起因因为在报错之前，实际上就曾经报错了其余谬误，然而没有打印进去。解决办法在tomcat部署目录下的我的项目classes目录新建文件 handlers = org.apache.juli.FileHandler, java.util.logging.ConsoleHandler org.apache.juli.FileHandler.level = FINE org.apache.juli.FileHandler.directory = ${catalina.base}/logs org.apache.juli.FileHandler.prefix = error-debug. java.util.logging.ConsoleHandler.level = FINE java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter完了之后，就会看到真正的谬误起因。

关于tomcat:TomcatHTTP总结1

Tomcat、HTTP总结1服务器概述什么是服务器？服务器分为服务器硬件和服务器软件。在硬件服务器上安装了服务器软件，能力对外提供服务。服务器硬件：在互联网上具备独立ip地址的计算机服务器软件：就是计算机上的一个程序，比方tomcat服务器软件，mysql服务器软件等。同时服务器软件的分类有很多种：web服务器软件，数据可服务器软件，邮件服务软件等。什么是web服务器？web服务器是指驻留在互联网上的某种类型的计算机程序，当浏览器向服务器发送申请时，服务器就会接管来自浏览器的申请并解决，并响应浏览器，并会附带一些信息通知浏览器如何查看该文件。web服务器是一个能够向“发送申请的浏览器提供文档”的程序。咱们在拜访网页的时候，就是在拜访他们的服务器。tomcat就是一个web服务器软件。Tomcat的下载、装置、配置tomcat的下载地址:https://tomcat.apache.org/download-80.cgi tomcat的应用须要jdk的反对tomcat5 须要jdk4以上反对tomcat6 须要jdk5以上反对tomcat7 须要jdk6以上反对tomcat8 须要jdk7以上反对解压后须要配置jdk的环境，指定运行的jdk版本最初测试拜访：http://localhost:8080 tomcat批改默认端口：为了不便能够把8080端口设置为80端口，因为80端口能够默认不写。找到解压tomcat的目录中[*tomcat/config/server.xml] <Connector connectionTimeout="20000" port="80" protocol="HTTP/1.1" redirectPort="8443"/>把port批改为80即可。如果在应用tomcat中遇到server port ... are already ues能够点击tomcat/bin/shutdown.bin 敞开服务器之后重启。虚拟主机虚拟主机就是tomcat服务器中配置的一个站点，在tomcat服务器中默认配置了一个localhost虚拟主机，这个主机的公布目录是webapps目录；这就是说，Web利用应该放在webapps目录下。webapps目录的构造：webapps --其余目录， --WEB—INF目录： --classes目录：编译后的class文件 --lib目录：用于寄存web利用所以来的jar包 --web.xml文件，用于寄存和web利用相干的一些配置配置WEB利用的主页在web利用的WEB-INF/web.xml文件中退出一下代码：<?xml version="1.0" encoding="UTF-8"?><web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1"> <welcome-file-list> <welcome-file>/hello.html</welcome-file> <welcome-file>/hello1.html</welcome-file> <welcome-file>/hello2.html</welcome-file> </welcome-file-list></web-app>把web利用打成war包选中应用程序，压缩成zip之后把zip后缀改成war即可。

关于tomcat:Tomcat优化你值得拥有

最艰难的事件就是意识本人！集体网站，欢送拜访！前言：Tomcat作为Web利用的服务器，目前绝大多数公司都是用其作为应用服务器的；应用服务器的执行效率会影响零碎执行，这里会讲Tomcat怎么进行配置能进步解决性能；除此之外也必然会提到对应的JVM参数的优化的一些教训。本文为转载文章，原文地址：系统优化怎么做-Tomcat优化 Tomcat的运行模式：运行模式分3种模式： bio：默认的模式，效率比拟低nio：优化时应用的模式apr：对系统配置有一些比拟高的要求确认Tomcat运行模式：查找配置文件 server.xml ，在tomcat下的门路：conf 目录下；Executor 为自定义配置 Tomcat 线程池： <Executor name="tomcatThreadPool" namePrefix="catalina-exec-" maxThreads="1024" minSpareThreads="512" prestartminSpareThreads="true" />要害配置：maxThreads：最大线程数，默认是200minSpareThread：最小沉闷线程数，默认是25maxQueueSize：最大的期待队列个数，超过则申请回绝默认值是Integer.MAX_VALUE ，个别不扭转。在某些紧急状态修复问题须要调整连接器（Connector）：Connector是连接器，负责接管客户的申请，以及向客户端回送响应的音讯。所以Connector的优化是重要局部。默认状况下 Tomcat只反对200线程拜访，超过这个数量的连贯将被期待甚至超时放弃，所以咱们须要进步这方面的解决能力。nio 配置：配置文件 server.xml<Connector port="14081" protocol="org.apache.coyote.http11.Http11NioProtocol"connectionTimeout="20000"executor="tomcatThreadPool" URIEncoding="UTF-8" compression="on" useBodyEncodingForURI="true" enableLookups="false" redirectPort="14443" />影响性能的配置：protocol：org.apache.coyote.http11.Http11Protocol - 阻塞式的Java连接器org.apache.coyote.http11.Http11NioProtocol - 不阻塞Java连接器org.apache.coyote.http11.Http11AprProtocol - APR / native 连接器抉择不阻塞Java连接器enableLookups：若是你想request.getRemoteHost()的调用履行，以便返回的短途客户端的理论主机名的DNS查问，则设置为true。设置为false时跳过DNS查找，并返回字符串的IP地址（从而进步性能）。默认场景下，禁用DNS查找。compression：设置成on，开启压缩禁用AJP链接器:应用Nginx+tomcat的架构，用不着AJP协定，所以把AJP连接器禁用server.xml正文掉以下配置： <Connector port="8019" protocol="AJP/1.3" redirectPort="8443" />优化 JVM：优化地位：/bin/catalina.sh批改 JAVA_OPTS 参数，这里须要参照机器配置，对JVM进行参数优化。 JDK1.7：JAVA_OPTS="-Djava.awt.headless=true -Dfile.encoding=UTF-8 -server -Xms512m -Xmx1024m -XX:NewSize=512m -XX:MaxNewSize=1024M -XX:PermSize=1024m -XX:MaxPermSize=1024m -XX:+DisableExplicitGC"JDK1.8：JAVA_OPTS="-Djava.awt.headless=true -Dfile.encoding=UTF-8 -server -Xms1024m -Xmx1024m -XX:NewSize=512m -XX:MaxNewSize=1024M -XX:+DisableExplicitGC"留神：1.8 中曾经没有永恒代了，所以也就没有没有PermSize、MaxPermSize ；Java8 中将永恒代改为了元空间了，JAVA8里对metaspace能够在小范畴主动扩大永生代防止溢出。 ...

关于tomcat:部署tomcat项目

mac上间接启动tomcat切到目录apache-tomcat-8.5.32/bin执行命令sh startup.sh启动胜利terminal上能够看到Tomcat started. 拜访http://localhost:8080/ bingo 敞开tomcat的时候执行命令sh shutdown.sh 跑一个tomcat目录下的我的项目apache-tomcat-8.5.32/webapps 比方这个目录下有一个manager我的项目,外面提供了一个index.jsp 拜访http://localhost:8080/manager/index.jsp 比方examples中配置的web.xml中有一条 <servlet-mapping> <servlet-name>HelloWorldExample</servlet-name> <url-pattern>/servlets/servlet/HelloWorldExample</url-pattern> </servlet-mapping>拜访http://localhost:8080/examples/servlets/servlet/HelloWorldExample idea 只含一个servlet的tomcat web新建一个java web我的项目new project -> java enterprise -> 抉择tomcat作为application server -> 勾选create project from template 创立一个servlet，在web.xml 中配置相应的servlet配置配置tomcat （配置过程省略），配置Deployment的时候Application context配置成和我的项目一样的名字启动tomcat，拜访http://localhost:8080/selfjavawebproj/myservlet selfjavawebproj是web application的名字，myservet须要是在web.xml中配置的门路 tomcat的容器层级tomcat的Servlet容器分为了四层，Engine->Host->Context->Wrapper最内层的Wapper示意一个Servlet，Context示意一个应用程序，一个应用程序中会蕴含多个servlet，Host示意一个站点，一个站点下能够有多个应用程序，Engine示意引擎，用来治理多个站点。在tomcat中的conf/server.xml中，能够配置多个service以我的配置文件为例 <server> <Service name="Catalina"> //一个service下能够有多个connector，一个engine <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" /> <Connector port="8009" protocol="AJP/1.3" redirectPort="8443"/> <Engine name="Catalina" defaultHost="localhost">//蕴含多个host <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true"> </Engine> </service> <service> </service></server>tomcat实现容器的时候定义了Container，外面定义了parent child这种角色，通过组合模式组装每一层级的容器 public interface Container extends Lifecycle { public void setName(String name); public Container getParent(); public void setParent(Container container); public void addChild(Container child); public void removeChild(Container child); public Container findChild(String name);}http://localhost:8080/selfjavawebproj/myservlet当收回这个申请时，1 首先依据协定和端口号抉择service和Engine，对应下面的配置，只有一个service且连接器反对HTTP1.1，端口8080，所以找到了name为Catalina的service和name为Catalina的Engine2 依据拜访的域名 localhost找到对应的host3 依据url找到context，所以在后面配置的时候Application context配置的也是利用名称，在这里context就是selfjavawebproj4 依据url找到Wrapper，即依据配置的门路在web.xml中找到对应的servlet实现类 ...

关于tomcat:部署tomcat项目

关于tomcat:Tomcat-架构原理解析到架构设计借鉴

Tomcat 倒退这么多年，曾经比拟成熟稳固。在现在『追新求快』的时代，Tomcat 作为 Java Web 开发必备的工具仿佛变成了『相熟的陌生人』，难道说现在就没有必要深刻学习它了么？学习它咱们又有什么播种呢？静下心来，细细品味经典的开源作品。晋升咱们的「内功」，具体来说就是学习大牛们如何设计、架构一个中间件零碎，并且让这些教训为我所用。美妙的事物往往是整洁而优雅的。但这并不等于简略，而是要将简单的零碎分解成一个个小模块，并且各个模块的职责划分也要清晰正当。与此相反的是凌乱无序，比方你看到城中村一堆相互纠缠在一起的电线，可能会感到不适。保护的代码一个类几千行、一个办法好几百行。办法之间互相耦合糅杂在一起，你可能会说 what the f*k！学习目标把握 Tomcat 架构设计与原理进步内功宏观上看 Tomcat 作为一个「Http 服务器 + Servlet 容器」，对咱们屏蔽了应用层协定和网络通信细节，给咱们的是规范的 Request 和 Response 对象；对于具体的业务逻辑则作为变动点，交给咱们来实现。咱们应用了SpringMVC 之类的框架，可是却从来不须要思考 TCP 连贯、 Http 协定的数据处理与响应。就是因为 Tomcat 曾经为咱们做好了这些，咱们只须要关注每个申请的具体业务逻辑。宏观上看 Tomcat 外部也隔离了变动点与不变点，应用了组件化设计，目标就是为了实现「俄罗斯套娃式」的高度定制化（组合模式），而每个组件的生命周期治理又有一些共性的货色，则被提取进去成为接口和抽象类，让具体子类实现变动点，也就是模板办法设计模式。当今风行的微服务也是这个思路，依照性能将单体利用拆成「微服务」，拆分过程要将共性提取进去，而这些共性就会成为外围的根底服务或者通用库。「中台」思维亦是如此。设计模式往往就是封装变动的一把利器，正当的使用设计模式能让咱们的代码与零碎设计变得优雅且整洁。这就是学习优良开源软件能取得的「内功」，从不会过期，其中的设计思维与哲学才是基本之道。从中借鉴设计教训，正当使用设计模式封装变与不变，更能从它们的源码中吸取教训，晋升本人的零碎设计能力。宏观了解一个申请如何与 Spring 分割起来在工作过程中，咱们对 Java 语法曾经很相熟了，甚至「背」过一些设计模式，用过很多 Web 框架，然而很少有机会将他们用到理论我的项目中，让本人独立设计一个零碎仿佛也是依据需要一个个 Service 实现而已。脑子里仿佛没有一张 Java Web 开发全景图，比方我并不知道浏览器的申请是怎么跟 Spring 中的代码分割起来的。为了冲破这个瓶颈，为何不站在伟人的肩膀上学习优良的开源零碎，看大牛们是如何思考这些问题。学习 Tomcat 的原理，我发现 Servlet 技术是 Web 开发的原点，简直所有的 Java Web 框架（比方 Spring）都是基于 Servlet 的封装，Spring 利用自身就是一个 Servlet（DispatchSevlet），而 Tomcat 和 Jetty 这样的 Web 容器，负责加载和运行 Servlet。如图所示： ...

关于tomcat:Trainee0727第二个任务在办公机启动一个项目part2

需要part2：启动我的项目、批改某些配置文件。实习一周多问题汇总办公机曾经装置过两个Tomcat服务器，加上这次的就会有三个版本的Tomcat，启动时不出所料地error。如何从零开始通过war包启动一个我的项目？第一次启动Spring Boot我的项目下载工夫长的问题。IDEA创立新我的项目时maven库不是本机指定的目录。问题解决多版本Tomcat问题批改环境变量：变量名本人定，然而不能是CATALINA_HOME。因为这个变量名曾经被之前版本用了。前面在批改.bat文件时本人能辨别变量名就好。Path中也要批改为：%CATALINA_HOME70104%\bin，考究个对应。而后进入Tomcat门路下bin文件夹，找到startup.bat，右键抉择编辑：外面所有的CATALINA_HOME改为本人定的名字，比方这里我的CATALINA_HOME70104：还是这个文件夹，找到catalina.bat文件，右键编辑，编辑办法同startup.bat。上一步防止了Tomcat启动时版本的抵触，上面解决启动时端口的抵触：进入Tomcat门路下conf文件夹，找到server.xml，有三处须要进行端口的批改：通过war包启动我的项目进入Tomcat目录，找到其中的webapps文件夹，将我的项目的war包以及须要的文件、文件夹之类放入其中，回到Tomcat门路的bin文件夹，双击startup.bat启动我的项目，war文件会被主动解压。第一次启动Spring Boot我的项目下载工夫长因为maven从外网下载，国内拜访速度慢，能够更改为阿里云镜像。找到本人装置门路下的settings.xml文件（比方我的在D:\Developer\Maven\apache-maven-3.6.3\conf中），编辑：首先在<mirrors></mirrors>节点中增加子节点： <mirror> <id>alimaven</id> <name>aliyun maven</name> <url>http://maven.aliyun.com/nexus/content/groups/public/</url> <mirrorOf>central</mirrorOf> </mirror>改为而后批改本地仓库地址<localRepository>本人的repository门路</localRepository> 改为IDEA每次创立新我的项目时都须要手动指定本机maven库首先，我是IDEA2020.1版本。找到File➡New Projects Settings➡Settings for New Projects... 批改如下选项为本人的Maven库

关于tomcat:Trainee0727第二个任务在办公机启动一个项目part1

需要老大写好的我的项目打成war包，须要在我这台办公机启动。 part1：办公机的环境须要配置；part2：启动我的项目、批改某些配置文件；配置环境前提常识war包 war包个别是在进行Web开发时，通常是一个网站Project下的所有源码的汇合，外面蕴含前台HTML/CSS/JS的代码，也蕴含Java的代码。当开发人员在本人的开发机器上调试所有代码并通过后，为了交给测试人员测试和将来进行产品公布，都须要将开发人员的源码打包成War进行公布。 War包能够放在Tomcat下的webapps或者word目录下，随着tomcat服务器的启动，它能够主动被解压 Tomcat服务器 Tomcat服务器是一个收费的凋谢源代码的Web应用服务器，属于轻量级应用服务器，在中小型零碎和并发拜访用户不是很多的场合下被广泛应用，是开发和调试JSP程序的首选，最新的Servlet和JSP标准总是能在Tomcat中失去体现。Redis Redis是一款内存高速缓存数据库，全称为Remote Dictionary Server，即近程字典服务，是一个开源的应用ANSI C语言编写、反对网络、可基于内存亦可长久化的日志型、Key-Value（键值）数据库，并提供多种语言的API。AvtiveMQ 用处：用来解决音讯，也就是解决JMS的。音讯队列在大型电子商务类网站，如京东、淘宝、去哪儿等网站有着深刻的利用，队列的次要作用是打消高并发拜访顶峰，放慢网站的响应速度。 JMS即Java音讯服务（Java Message Service）利用程序接口，是一个Java平台中对于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送音讯，进行异步通信。音讯队列(Message Queue/MQ)：在音讯的传输过程中保留音讯的容器。在不应用音讯队列的状况下，用户的申请数据间接写入数据库，高发的状况下，会对数据库造成微小的压力，同时也使得零碎响应提早加剧，但应用队列后，用户的申请发给队列后立刻返回。例如：购物app不能间接给用户提醒订单提交胜利，app会提醒：“您提交了订单，请期待零碎确认”，再由音讯队列的消费者过程从音讯队列中获取数据，异步写入数据库。因为音讯队列的服务处理速度远快于数据库，因而用户的响应提早可失去无效改善。ElasticSearch 应用JAVA开发、基于Lucene搜索引擎库的全文搜寻工具，通过RESTful API（一种接口设计规范，让接口更易懂）暗藏了Lucene本来的复杂性。实现了日志数据的分布式、实时剖析，并且能够进行搜寻补全与纠错等性能，是ELK最外围的组件。相比MySQL库和表的概念，在ES中把库叫做索引。Tomcat1、下载资源进入官方网站下载页面，下载Tomcat 7.x版本服务器：下载后解压缩到本人想要的门路中，比方：D:\tomcat\apache-tomcat-7.0.104。 2、设置Tomcat环境变量此电脑 ➡ 属性 ➡ 高级零碎设置 ➡ 环境变量新建一个环境变量：变量名：TOMCAT_HOME变量值：你的tomcat解压后的目录，如D:\tomcat\apache-tomcat-7.0.104。在零碎变量中的Path增加：%TOMCAT_HOME%\bin; 3、验证Tomcat环境变量的配置是否胜利运行Tomcat解压目录下的bin\startup.bat，启动Tomcat服务器。在浏览器拜访http://localhost:8080，如果界面显示如下，则阐明Tomcat的环境变量配置胜利。 Tomcat目录 -> bin文件夹下 startup.bat启动tomcat服务器；shutdown.bat敞开tomcat服务器。插曲：Tomcat命令行窗口中文乱码问题问题剖析：家喻户晓，绝大多数的中文乱码问题都是因为：字节流解码为字符串时，应用了谬误（和编码所用字符集不统一）的字符集。解决方案：Tomcat目录 -> conf文件夹，找到logging.properties，关上并编辑：找到如下配置项：java.util.logging.ConsoleHandler.encoding = UTF-8将 UTF-8 批改为 GBK：java.util.logging.ConsoleHandler.encoding = GBK 重启Tomcat： Redis1、下载资源Redis官网：https://redis.io/download，然而这里下载的是Linux版本的Redis，Windows须要在Microsoft凋谢技术小组中下载。 2、装置和配置Redis倡议勾选，性能是增加Redis目录到环境变量PATH中，这样不便零碎自动识别Redis执行文件在哪里。端口号可放弃默认的6379，并抉择防火墙例外，从而保障内部能够失常拜访Redis服务。设定最大值为100M。作为试验和学习，100M足够了。上面进行配置：因为是采纳msi文件装置的办法，不须要再装置和注册redis到window服务，默认曾经启动。启动服务命令：redis-server.exe --service-start敞开服务命令：redis-server.exe --service-stop也能够在windows的利用：服务中开启/敞开。启动测试： redis-server.exe redis.windows.conf命令： 3、一些设定工作为了平安还须要给redis设置明码，默认装置后是没有明码的：关上Redis服务配置文件：redis.windows-service.conf。找到requirepass行加上本人的明码即可，如下图所示，批改后须要重启redis服务。设置明码的办法：删除正文（#），foobared改为本人的明码。验证明码是否胜利、Redis是否失常工作：首先，设置明码后重启服务。其次，进入redis目录，执行redis-cli，启动客户端程序。而后，输出auth 明码进行验证。最初，通过set、get命令测试性能。 ActiveMQ1、下载资源进入官网下载页面，抉择本人须要的版本下载。这里因为我的项目须要ActiveMQ 5.11.0 Release，所以能够进入past release找到须要的版本并下载。2、装置相似Tomcat，zip文件解压后间接能够应用，无需装置。 ...

Tomcat下载与配置

Tomcat介绍Tomcat是Apache组织的一个开源收费的容器，用来治理web开发我的项目，能够用来治理JSP、Servlet本篇文章下载的是Tomcat9版本的下载到apache官网下载，网址如下：www.apache.org进入之后拉到最上面的APACHE PRODUCT LIST选中Tomcat，抉择Tomcat9我的电脑是windows64位的，所以抉择Core中64位的版本，如果是Linux零碎的，抉择tar.gz版本。如果想要看源码的下载Source Code下的版本，windows版本用zip，Linux版本的用tar.gz。 Tomcat文件介绍下载的Tomcat文件夹下有如下几个文件夹 bin文件夹：和服务器启动相干的文件conf文件夹：和配置文件相干的，该文件夹下有两个比拟重要的 web.xml：是和申请相干的server.xml：和服务器本身的信息相干的，比方端口号lib文件夹：寄存jar包logs文件夹：日志信息temp文件夹：寄存临时文件webapps文件夹：用来寄存部署在容器内的我的项目资源work文件夹：用来寄存解析JSP后造成的java文件Tomcat配置下载实现之后，我这里用的是IDEA 2019编译器运行Tomcat。关上IDEA，新建一个我的项目，抉择JAVA EE下的web Application 抉择IDEA上的RUN--->Edit Configuration 点击左上角的加号，之后抉择Tomcat的Local版本如果没看到Tomcat可能是没有装置Tomcat插件，点击菜单栏的File-->settings-->plugins-->找到Tomcat选中-->点击Apply，就能够了，而后再反复第二步进入到第二步的图片所示的地位，点击图片右侧Server下的ConfigureTomcat Home中抉择下载的Tomcat的地位，之后base directory会呈现和Tomcat Home一样的地位，点击OK就行默认浏览器应用的是谷歌，如果选中After launch，默认是服务器运行之后本人关上默认的浏览器运行Tomcat容器后在控制台应该会呈现乱码的问题，解决方案如下点击Run--->Edit Configuration,在VM options中输出-Dfile.encoding=UTF-8 点击Help---->Edit Custom VM options，在最初一行增加-Dfile.encoding=UTF-8（留神：如果是到IDEA目录下批改编译器配置的可能不好用，我之前就是这样没有成果）这样配置完应该就能失常应用了运行这里咱们简略运行一个网页界面，在web文件夹下创立一个html文件运行后果如下：留神：如果创立的html文件不是叫index，服务器会运行index.jsp，如果web文件夹下没有index.html或者index.jsp，默认关上的话会找不到资源，因为服务器运行之后默认关上网站时，Tomcat配置文件下默认的资源名称是index。如果想要拜访不是以index为名称的资源就在URL网址前面加上资源名称比方我把index.jsp文件删掉，而后再把index.html的名称改为hello.html，重启服务器，后果如下：在URL前面增加具体资源名称后，后果如下：如果没有抉择默认开启，就关上一个浏览器在浏览器里输出网址，网址是：http://localhost:8080/项目名称/具体资源名称

Tomcat类加载机制浅析

前言Tomcat 是后端服务最常见的web容器，关于 Tomcat 一个重要的话题就是它的类加载机制，本文就基于 9.0.16 版本浅析一下 Tomcat 的类加载机制有几个类加载器？在Tomcat的启动类 org.apache.catalina.startup.Bootstrap 里定义了三个 ClassLoader 类型的属性 ClassLoader commonLoader = null;ClassLoader catalinaLoader = null;ClassLoader sharedLoader = null;在 Bootstrap 的 main 方法里会先 new 一个 Bootstrap 对象，然后调用 Bootstrap#init 方法，并在 init 方法里调用其 initClassLoaders 方法来初始化这三个属性。 private void initClassLoaders() { try { commonLoader = createClassLoader("common", null); if( commonLoader == null ) { // no config file, default to this loader - we might be in a 'single' env. commonLoader=this.getClass().getClassLoader(); } catalinaLoader = createClassLoader("server", commonLoader); sharedLoader = createClassLoader("shared", commonLoader); } catch (Throwable t) { …… }}private ClassLoader createClassLoader(String name, ClassLoader parent) throws Exception { String value = CatalinaProperties.getProperty(name + ".loader"); if ((value == null) || (value.equals(""))) return parent; …… return ClassLoaderFactory.createClassLoader(repositories, parent);}最后一句的 ClassLoaderFactory.createClassLoader 返回的是一个 URLClassLoader 对象。 ...

一个Tomcat-如何部署多个项目附多种解决方案及详细步骤

此文源自一次多年前面试的面试题，民工哥将它总结出来分享给大家，希望对大家有所帮助，或者今后的面试中说不定会用的上。首先，我们了解一下常见的Java Web服务器。 Tomcat：由Apache组织提供的一种Web服务器，提供对jsp和Servlet的支持。它是一种轻量级的javaWeb容器（服务器），也是当前应用最广的JavaWeb服务器（免费）。Jboss：是一个遵从JavaEE规范的、开放源代码的、纯Java的EJB服务器，它支持所有的JavaEE规范（免费）。GlassFish：由Oracle公司开发的一款JavaWeb服务器，是一款强健的商业服务器，达到产品级质量（应用很少，收费）。Resin：是CAUCHO公司的产品，是一个非常流行的应用服务器，对servlet和JSP提供了良好的支持，性能也比较优良，resin自身采用JAVA语言开发（收费，应用比较多）。WebLogic：是Oracle公司的产品，是目前应用最广泛的Web服务器，支持JavaEE规范，而且不断的完善以适应新的开发要求，适合大型项目（收费，用的不多，适合大公司）。Tomcat就是实际环境中最常见的，很多时候，特别是像在平时的测试环境，经常会遇到多个项目同时测试的情况，所以，今天民工哥与大家来聊一聊如何在一个Tomcat服务下，同时部署多个应用项目。 1、不修改端口大家都知道，应用项目是直接放在Tomcat webapps目录下面 [root@CentOS7-1 tomcat]# cd webapps/[root@CentOS7-1 webapps]# lltotal 4drwxr-x--- 16 root root 4096 Jun 4 03:07 docsdrwxr-x--- 6 root root 83 Jun 4 03:07 examplesdrwxr-x--- 5 root root 87 Jun 4 03:07 host-managerdrwxr-x--- 5 root root 103 Jun 4 03:07 managerdrwxr-x--- 3 root root 283 Jun 4 03:07 ROOT所以，我们在不修改端口的情况下，可以直接在此目录下新增多个项目目录，也可以直接将war包放在此目录下，由于测试环境，我们直接模拟war解压后的目录，用添加目录来替代。 [root@CentOS7-1 webapps]# mkdir test java[root@CentOS7-1 webapps]# lsdocs examples host-manager java manager ROOT test准备测试的首页文件 [root@CentOS7-1 webapps]# echo "this is a test" >test/test.html[root@CentOS7-1 webapps]# echo "this is a java" >java/java.html[root@CentOS7-1 webapps]# cat test/test.htmlthis is a test[root@CentOS7-1 webapps]# cat java/java.htmlthis is a java修改配置文件  <Context path="test/" docBase="test" reloadable="true" /> <Context path="java/" docBase="java" reloadable="true" /> #增加上两行配置即可 </Host> </Engine> </Service></Server>"../conf/server.xml" 173L, 7744CdocBase属性: 指定Web应用的文件路径，可以是绝对路径，也可以给定相对路径path属性: 指定访问该Web应用的URL入口。 reloadable属性: 若这个属性为true，tomcat服务器在运行状态下会监视WEB-INF/classes和WEB-INF/lib目录下class文件的改动，如果监测到class文件被更新，服务器会自动重新加载Web应用。重启Tomcat服务，测试访问，结果如下：部署成功。注：配置文件中增加的配置步骤可以不做，直接跳过，不是必须要做的步骤。2、修改端口第二种修改端口的方法，其实是基于第一种方法做出的改良，在tomcat目录下创建多个webapps目录。删除webapps目录下的java项目，并删除webapps1目录下test项目即可。修改配置文件 server.xml已有第一个项目的配置信息，现在需要新增第二个项目的配置，在Server节点下，新增一个Service节点，第2个Service节点直接复制第1个Service内容修改即可。 <Service name="Catalina1">  <Connector port="8081" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />  <Engine name="Catalina1" defaultHost="localhost">  <Realm className="org.apache.catalina.realm.LockOutRealm">  <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase"/> </Realm> <Host name="localhost" appBase="webapps1" unpackWARs="true" autoDeploy="true"> <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log" suffix=".txt" pattern="%h %l %u %t "%r" %s %b" /> </Host> </Engine> </Service>只需要注意修改几个配置即可，不太熟悉的读者，可以利用代码工具比较一下，就会发现两段配置的不同，这里就不多解释了。 ...

Tomcat9配置HTTP2

1 概述Tomcat从Tomcat8的一些较新版本就支持HTTP/2了，Tomcat9直接支持，本文首先讲述了相关HTTP/2的特性，接着利用一个简单的开源工具mkcert生成证书并利用该证书配置HTTP/2。 2 HTTP/2特性首先介绍一下HTTP/2特性，这也从另一方面解释了为什么需要使用HTTP/2。 2.1 二进制分帧HTTP/2在应用层与传输层增加了一个二进制分帧，能够达到“在不改动HTTP语义，HTTP方法，状态码，URI及首部字段的情况下，突破HTTP/1.1的性能限制，改进传输性能，实现低延迟和高吞吐量。” 2.2 压缩头部HTTP/2对消息头采用了HPACK进行压缩传输，能够节省消息头占用的网络流量，而HTTP/1.x每次请求都会携带大量的冗余头信息，浪费了很多带宽资源。 2.3 多路复用简单地说就是所有的请求都通过一个TCP连接并发完成。HTTP/1.x虽然能利用一个连接完成多次请求，但是多个请求之间是有先后顺序的，后面发送的请求必须等待上一个请求返回才能发送响应，很容易导致后面的请求被阻塞。而HTTP/2做到了真正的并发请求。HTTP/2将消息分解为帧，为每帧分配一个流标识符，然后在一个TCP连接上独立发送，HTTP/2将请求帧与响应帧交织在一起，能够让所有请求与响应都在一个套接字上发生，所有请求或响应都无法相互阻塞，减少了延迟，提高了页面加载速度，消除了对HTTP/1.1工具的需求。 2.4 流优先及流控制消息帧通过对流进行发送，每个流分配了一个优先级，用于确定处理顺序以及收到的资源量，优先级可以是0-256之间的数字，可以定义依赖关系，允许在一个资源之前加载另一个资源。流控制管理数据的传输，允许接收者停止或减少发送的数据量，比如观看视频暂停时，客户端会通知服务器停止发送视频数据。 2.5 服务器推送一般情况下需要客户端请求服务器才会响应，HTTP/2中能够先于客户端检测将要请求的资源，提前通知客户端，但是不发送资源只发送URL，客户端收到后会进行验证缓存，发现需要则正式发起请求。 2.6 应用层协商协议客户端与服务器都升级才能支持HTTP/2，但是有可能存在HTTP/1与HTTP/2并存的情况，如果都使用80端口，需要选择其中一个协议通信。APLN（Application Layer Protocol Negotiation）就是为了解决这个问题，通过协商选择协议：首先客户端发起请求，如果支持HTTP/2则带upgrade头部若服务器不支持则拒绝升级通过HTTP/1.1返回响应若服务器支持则接受升级，切换到新分帧使用HTTP/2通信更多请查看RFC7540 官方文档。 3 使用mkcert生成证书网上大部分的教程都是使用OpenSSL生成根证书，客户端证书以及服务端证书的，一堆参数配置非常复杂，因此这里使用一个简单的一键生成本地证书的开源工具mkcert，无需任何配置。 3.1 安装mkcert3.1.1 MacOSbrew install mkcertbrew install nss # 如果使用火狐使用MacPorts： sudo port selftupdatesudo port install mkcertsudo port install css # 如果使用火狐3.1.2 Linux需要先安装certutil： #Debian/Ubuntusudo apt install libnss3-tools#Red Hat/Fedora/CentOSsudo yum install nss-tools#Arch/Manjarosudo pacman -S nss#SUSEsudo zypper install mozilla-nss-tools使用LinuxBrew安装： brew install mkcert安装LinuxBrew： /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"Arch/Manjaro可以使用pacman安装： ...