maven项目中的tomcat版本问题
 
 
 
本文章分享自己在学习maven基础学习过程中遇到的一些问题，并附上自己解决的方法
 
 
为MyServlet进行 如下xml的配置
 
 
并且对jar包进行如下配置：
 
 
其中MyServlet中实现一个转发功能：
 
 
然后将项目run
 执行mvn tomcat:run
 
 然后访问http://localhost:8080/maven/MyServlet，发现出错：
 
 这个问题是由于maven中内置的默认tomcat插件是6版本。由于低版本的tomcat和高版本的jdk不适用问题造成的。
 我们可以在pom.xml文件中配置tomcat的版本：
 然后通过mvn tomcat7:run
 
 
这样就可以解决了
 成功完成转发
 

如果pom.xml文件用到了tomcat插件的话
 启动tomcat只需要两步
 第一步：
 
 第二步：
 

最近学习Tomcat源码，平时新建maven项目的时候，使用springboot内嵌tomcat启动，现在需要使用外部tomcat启动，以便于学习tomcat和spring代码之间的执行关系。 添加完外部tomcat后突然发现无法将 maven项目的web项目添加到tomcat中。
 
 
 
就是通过下图添加maven的 web项目，如过在JavaEE窗口下，项目中没有Deployment Descriptor：  的标记可能你的项目是无法添加到tomcat中的。
 
 
 
 
因此你想让你的项目可以添加到Tomcat中，需要按照下面的步骤来操作自己的项目。
 
1.首先 鼠标右键项目属性  properties。
 
2.选择 Project Facets 进行添加Dynamic Web Module选项，你可以选择其中的版本信息。
 
3.应用到项目，最后你就可以添加了。
 
 
 
 
 
 
按照上面的步骤可能你就可以将项目添加到Tomcat中了，但是你不一定能运行成功，因为还需要在你的pom文件中添加一些引用：
 
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
                <version>2.1.1.RELEASE</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
	            <groupId>org.springframework.boot</groupId>
	            <artifactId>spring-boot-starter-web</artifactId>
	        </dependency>
 
以及在启动类中做一些改变：
 
加一个@ServletComponentScan 注解，以及继承  SpringBootServletInitializer 类，然后重写 configure(SpringApplicationBuilder springApplicationBuilder)方法。关于为什么需要继承SpringBootServletInitializer 后续可能做出进一步的分析。
 
 
 
 
看一下  SpringBootServletInitializer 的具体实现。这个类实现了WebApplicationInitializer 接口。
 
此处你只需要知道:
 
 
 
在tomcat启动的时候会通过java 的SPI机制 加载Spring-web jar目录下的文件然后加载类
 
 
SpringServletContainerInitializer ，然后此类会在tomcat启动时掉用他的onStartup 方法。
 
 
StandardContex初始化时会将实现了 WebApplicationInitializer 接口的类加载到 Context中，后面会调用 SpringServletContainerInitializer 类的onStartup方法时，做为参数Set<Class<?>> webAppInitializerClasses传入。后面会调用
 
 
WebApplicationInitializer实现类的的方法：
 
 
onStartup(ServletContext servletContext)。
 
 
想进一步了解其中原理可以看我的另一篇文章：
 
 
java SPI 机制 在Tomcat，spring-mvc启动及servlet3.0中的应用  
 
 
public abstract class SpringBootServletInitializer implements WebApplicationInitializer {

	protected Log logger; // Don't initialize early

	private boolean registerErrorPageFilter = true;

	/**
	 * Set if the {@link ErrorPageFilter} should be registered. Set to {@code false} if
	 * error page mappings should be handled via the server and not Spring Boot.
	 * @param registerErrorPageFilter if the {@link ErrorPageFilter} should be registered.
	 */
	protected final void setRegisterErrorPageFilter(boolean registerErrorPageFilter) {
		this.registerErrorPageFilter = registerErrorPageFilter;
	}

	@Override
	public void onStartup(ServletContext servletContext) throws ServletException {
		// Logger initialization is deferred in case an ordered
		// LogServletContextInitializer is being used
		this.logger = LogFactory.getLog(getClass());
		WebApplicationContext rootAppContext = createRootApplicationContext(
				servletContext);
		if (rootAppContext != null) {
			servletContext.addListener(new ContextLoaderListener(rootAppContext) {
				@Override
				public void contextInitialized(ServletContextEvent event) {
					// no-op because the application context is already initialized
				}
			});
		}
		else {
			this.logger.debug("No ContextLoaderListener registered, as "
					+ "createRootApplicationContext() did not "
					+ "return an application context");
		}
	}

	protected WebApplicationContext createRootApplicationContext(
			ServletContext servletContext) {
		SpringApplicationBuilder builder = createSpringApplicationBuilder();
		builder.main(getClass());
		ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
		if (parent != null) {
			this.logger.info("Root context already created (using as parent).");
			servletContext.setAttribute(
					WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
			builder.initializers(new ParentContextApplicationContextInitializer(parent));
		}
		builder.initializers(
				new ServletContextApplicationContextInitializer(servletContext));
		builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);
		builder = configure(builder);
		builder.listeners(new WebEnvironmentPropertySourceInitializer(servletContext));
		SpringApplication application = builder.build();
		if (application.getAllSources().isEmpty() && AnnotationUtils
				.findAnnotation(getClass(), Configuration.class) != null) {
			application.addPrimarySources(Collections.singleton(getClass()));
		}
		Assert.state(!application.getAllSources().isEmpty(),
				"No SpringApplication sources have been defined. Either override the "
						+ "configure method or add an @Configuration annotation");
		// Ensure error pages are registered
		if (this.registerErrorPageFilter) {
			application.addPrimarySources(
					Collections.singleton(ErrorPageFilterConfiguration.class));
		}
		return run(application);
	}

	/**
	 * Returns the {@code SpringApplicationBuilder} that is used to configure and create
	 * the {@link SpringApplication}. The default implementation returns a new
	 * {@code SpringApplicationBuilder} in its default state.
	 * @return the {@code SpringApplicationBuilder}.
	 * @since 1.3.0
	 */
	protected SpringApplicationBuilder createSpringApplicationBuilder() {
		return new SpringApplicationBuilder();
	}

	/**
	 * Called to run a fully configured {@link SpringApplication}.
	 * @param application the application to run
	 * @return the {@link WebApplicationContext}
	 */
	protected WebApplicationContext run(SpringApplication application) {
		return (WebApplicationContext) application.run();
	}

	private ApplicationContext getExistingRootWebApplicationContext(
			ServletContext servletContext) {
		Object context = servletContext.getAttribute(
				WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
		if (context instanceof ApplicationContext) {
			return (ApplicationContext) context;
		}
		return null;
	}

	/**
	 * Configure the application. Normally all you would need to do is to add sources
	 * (e.g. config classes) because other settings have sensible defaults. You might
	 * choose (for instance) to add default command line arguments, or set an active
	 * Spring profile.
	 * @param builder a builder for the application context
	 * @return the application builder
	 * @see SpringApplicationBuilder
	 */
	protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
		return builder;
	}

	private static final class WebEnvironmentPropertySourceInitializer
			implements ApplicationListener<ApplicationEnvironmentPreparedEvent>, Ordered {

		private final ServletContext servletContext;

		private WebEnvironmentPropertySourceInitializer(ServletContext servletContext) {
			this.servletContext = servletContext;
		}

		@Override
		public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
			ConfigurableEnvironment environment = event.getEnvironment();
			if (environment instanceof ConfigurableWebEnvironment) {
				((ConfigurableWebEnvironment) environment)
						.initPropertySources(this.servletContext, null);
			}
		}

		@Override
		public int getOrder() {
			return Ordered.HIGHEST_PRECEDENCE;
		}

	}

}
 
 
 
代码如下： 
 
@SpringBootApplication(scanBasePackages = {"com.hcgao","com.boot"})   
//@ComponentScan(basePackages = {"com.hcgao.*","com.boot.**"})
//@EnableAsync
@ServletComponentScan
public class Application extends SpringBootServletInitializer{
	
	@Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder springApplicationBuilder){
        return springApplicationBuilder.sources(Application.class);
    }
	
	public static void main(String[] args) throws Exception {
         SpringApplication.run(Application.class, args);
     }
}
 
 
 
添加完成后，如果你通过tomcat启动成功，那么祝贺你你成功了。
 但是我在这个地方又遇到了一点小问题。
 
下面看一下日志，tomcat虽然启动了，但是没有启动springBoot项目中的信息。
 
说明我们的springBoot项目并没有启动成功。
 
 
很明显是因为tomcat启动时没有扫描到 Maven中的jar，也没有加载到 spring-web的包
 
所以你需要通过下面的操作，将maven扫描包加载到项目中：
 
最后启动结果：
 
 
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: Server.服务器版本:     Apache Tomcat/9.0.34
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: 服务器构建:            Apr 3 2020 12:02:52 UTC
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: 服务器版本号(：9.0.34.0
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: OS Name:               Windows 10
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: OS.版本:               10.0
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: 架构:                  amd64
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: Java 环境变量:         H:\Program Files\Java\jdk1.8.0_211\jre
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: JVM 版本:              1.8.0_211-b12
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: JVM.供应商:            Oracle Corporation
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: CATALINA_BASE：[D:\gaohaichneg_jiagou\.metadata\.plugins\org.eclipse.wst.server.core\tmp0]
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: CATALINA_HOME:         G:\apache-tomcat-9.0.34
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: 命令行参数：[-Dcatalina.base=D:\gaohaichneg_jiagou\.metadata\.plugins\org.eclipse.wst.server.core\tmp0]
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: 命令行参数：[-Dcatalina.home=G:\apache-tomcat-9.0.34]
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: 命令行参数：[-Dwtp.deploy=D:\gaohaichneg_jiagou\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps]
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: 命令行参数：[-Djava.endorsed.dirs=G:\apache-tomcat-9.0.34\endorsed]
五月 02, 2020 3:42:15 下午 org.apache.catalina.startup.VersionLoggerListener log
信息: 命令行参数：[-Dfile.encoding=GBK]
五月 02, 2020 3:42:15 下午 org.apache.catalina.core.AprLifecycleListener lifecycleEvent
信息: The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [H:\Program Files\Java\jdk1.8.0_211\bin;C:\WINDOWS\Sun\Java\bin;C:\WINDOWS\system32;C:\WINDOWS;H:/Program Files/Java/jre1.8.0_211/bin/server;H:/Program Files/Java/jre1.8.0_211/bin;H:/Program Files/Java/jre1.8.0_211/lib/amd64;C:\Program Files (x86)\Common Files\Oracle\Java\javapath;C:\Windows\System32\wbem;H:\Program Files\Java\jdk1.8.0_211\bin;H:\Program Files\Java\jdk1.8.0_211\jre\bin;H:\Program Files\mysql-5.7.16-winx64\bin;E:\zookeeper-3.4.6\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;F:\oxygenEnvir\apache-maven-3.3.9\bin;F:\oxygenEnvir\nodeJs\;F:\oxygenEnvir\nodeJs\node_global;H:\Program Files\Git\cmd;H:\Program Files\Anaconda311111;C:\WINDOWS\System32\OpenSSH\;H:\AppData\Local\Programs\Python\Python37;D:\huanjing\gradle-6.0\bin;H:\Program Files\erl10.3\bin;H:\Program Files\RabbitMQ Server\rabbitmq_server-3.8.1\sbin;C:\Program Files (x86)\Windows Kits\8.1\Windows Performance Toolkit\;H:\Program Files\MATLAB\R2018a\runtime\win64;H:\Program Files\MATLAB\R2018a\bin;C:\Users\高海成\AppData\Local\Programs\Python\Python36\Scripts\;C:\Users\高海成\AppData\Local\Programs\Python\Python36\;H:\AppData\Local\Programs\Python\Python37\Scripts\;H:\AppData\Local\Programs\Python\Python37\;H:\AppData\Local\Programs\Python\Python36\Scripts\;H:\AppData\Local\Programs\Python\Python36\;C:\Users\高海成\AppData\Local\Microsoft\WindowsApps;C:\Users\高海成\AppData\Local\GitHubDesktop\bin;C:\Users\高海成\AppData\Roaming\npm;F:\oxygenEnvir\VS Code\bin;C:\Users\高海成\AppData\Local\Microsoft\WindowsApps;C:\Users\高海成\AppData\Local\BypassRuntm;h:\Program Files\JetBrains\PyCharm Community Edition 2019.3.1\bin;;D:\Users\YUNWEN\eclipse;;.]
五月 02, 2020 3:42:16 下午 org.apache.coyote.AbstractProtocol init
信息: 初始化协议处理器 ["http-nio-8080"]
五月 02, 2020 3:42:16 下午 org.apache.catalina.startup.Catalina load
信息: 服务器在[1,485]毫秒内初始化
五月 02, 2020 3:42:16 下午 org.apache.catalina.core.StandardService startInternal
信息: Starting service [Catalina]
五月 02, 2020 3:42:16 下午 org.apache.catalina.core.StandardEngine startInternal
信息: 正在启动 Servlet 引擎：[Apache Tomcat/9.0.34]
五月 02, 2020 3:42:23 下午 org.apache.jasper.servlet.TldScanner scanJars
信息: 至少有一个JAR被扫描用于TLD但尚未包含TLD。 为此记录器启用调试日志记录，以获取已扫描但未在其中找到TLD的完整JAR列表。 在扫描期间跳过不需要的JAR可以缩短启动时间和JSP编译时间。
五月 02, 2020 3:42:23 下午 org.apache.catalina.core.ApplicationContext log
信息: 2 Spring WebApplicationInitializers detected on classpath
Application Version: ${ruoyi.version}
Spring Boot Version: 2.1.1.RELEASE

//                          _ooOoo_                               //
//                         o8888888o                              //
//                         88" . "88                              //
//                         (| ^_^ |)                              //
//                         O\  =  /O                              //
//                      ____/`---'\____                           //
//                    .'  \\|     |//  `.                         //
//                   /  \\|||  :  |||//  \                        //
//                  /  _||||| -:- |||||-  \                       //
//                  |   | \\\  -  /// |   |                       //
//                  | \_|  ''\---/''  |   |                       //
//                  \  .-\__  `-`  ___/-. /                       //
//                ___`. .'  /--.--\  `. . ___                     //
//              ."" '<  `.___\_<|>_/___.'  >'"".                  //
//            | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //
//            \  \ `-.   \_ __\ /__ _/   .-` /  /                 //
//      ========`-.____`-.___\_____/___.-`____.-'========         //
//                           `=---='                              //
//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //
//             佛祖保佑       永不宕机      永无BUG               //

2020-05-02 15:42:25,587 [main] INFO  com.boot.Application - Starting Application on DESKTOP-1H6IM7E with PID 2300 (D:\gaohaichneg_jiagou\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps\hcgao-web\WEB-INF\classes started by 高海成 in D:\Users\YUNWEN\eclipse)
2020-05-02 15:42:25,597 [main] INFO  com.boot.Application - No active profile set, falling back to default profiles: default
2020-05-02 15:42:27,808 [main] INFO  o.s.context.support.PostProcessorRegistrationDelegate$BeanPostProcessorChecker - Bean 'asyncConfig' of type [com.boot.config.AsyncConfig$$EnhancerBySpringCGLIB$$79d742b2] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
2020-05-02 15:42:28,017 [main] INFO  org.apache.catalina.core.ContainerBase.[Catalina].[localhost].[/hcgao-web] - Initializing Spring embedded WebApplicationContext
2020-05-02 15:42:28,021 [main] INFO  org.springframework.web.context.ContextLoader - Root WebApplicationContext: initialization completed in 2350 ms
2020-05-02 15:42:30,176 [main] INFO  org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor - Initializing ExecutorService 'applicationTaskExecutor'
2020-05-02 15:42:31,316 [main] WARN  org.thymeleaf.templatemode.TemplateMode - [THYMELEAF][main] Template Mode 'HTML5' is deprecated. Using Template Mode 'HTML' instead.
2020-05-02 15:42:31,406 [main] INFO  org.springframework.boot.autoconfigure.web.servlet.WelcomePageHandlerMapping - Adding welcome page template: index
2020-05-02 15:42:31,684 [main] INFO  com.boot.Application - Started Application in 7.905 seconds (JVM running for 16.59)
2020-05-02 15:42:31,706 [main] INFO  org.apache.coyote.http11.Http11NioProtocol - 开始协议处理句柄["http-nio-8080"]
2020-05-02 15:42:31,716 [main] INFO  org.apache.catalina.startup.Catalina - Server startup in [14,903] milliseconds
 
 
 
最后终于启动成功了。
 
 
 
 

什么是maven工程？
 
		maven工程是一个项目管理工具，它包含了一个对于项目对象模型（POM)，一组标准集合，一个项目生命周期，一个项目管理系统和用来运行定义在生命周期阶段中插件目标的的逻辑。
		简单来说，就是来帮助你管理项目的一个工具，用来管理项目中需要用到的jar包，和工程之间的项目之间的关系的工具。
 
能够解决什么问题呢：
 
	 项目的开发过程包括,编译，测试，运行，打包，部署等步骤，对于这些既然繁琐而又技术量不高的方式完成可以使用相关的工具进行管理，而现在的maven项目管理工具就是这种工具。
	 优势：
	 		1. 项目中使用的jar包将会防止冲突，jar包的缺失扽该问题
	 		2. 项目的整体的体积小，能够将jar包专门存储到一个仓库中，当需要的时候，进行索引获取jar包，能够让项目的体积变得小巧，不需要大量的jar包存在工程中，导致项目体积庞大
 
maven的两个经典作用：
 
	1.maven的一个核心特性就是依赖管理，当我们涉及到多模块的项目（包含上百个模块的时候），管理依赖就变成一项很困难的任务，maven展示出了对于这种管理的强大控制
	对比：传统的web项目中，我们必须将工程所依赖的jar包复制到工程中去，导致了工程将会变得非常庞大，而maven工程的方式不是直接将jar包导入到工程中去，而是通过在pom.xml.也就是项目的配置文件中添加所需要的jar包的坐标。在需要使用jar包的时候，只要查找pom.xml文件，再通过jar包进行索引查找maven仓库中根据坐标找到相应的jar包

	疑问：
			jar包在哪里？长什么样子？是不不是通通过索引的方式将会变得很慢，项目的性能会不i会收到影响
			
	解答：
			1. jar包存放再jar包的仓库，仓库中放置了相关几乎所有开发需要用到的包，可以根据需求进行查找
			2. 仓库中是一个大的文件管理系统，里面有相关文件和文件夹，不同的文件中存放着不同的jar包的资源，已经进行了项目的jar包的分类
			3. 不用担心性能的问题。jar的存在和依赖于已经被maven开发人员解决了，提供类似于数组中的索引的机制，实现查找快，可以快速建立，快速查找的机制，大大提高了加载jar包的速度，使得我们认为jar包基本跟放在本地的工程中在进行读取的速度是一样的，这个过使用的是搜索类似于Luces来实现的，通过搜关键字进行索引实现
 
项目的一键构建：
 
			1. 一键构建指的是：项目从编译，测试，运行，打包，安装，部署整个过程都交给maven进行管理，这个过程称为构建
			2. 特指整个过程，使用maven一个命令可以轻松的完成整个工作
			3. 一键运行的命令：tomcat :run


maven工程的规范化构建过程如下：
			
			清理（mvn clean),编译（mvn  compile）,测试(mvn test),报告(),打包（mvn package）,安装部署(mvn install) 
 
 
maven的安装：
 
		1. maven的使用需要的是jdk 1.7+的版本
		2. 需要jdk设置好了  环境变量  path变量（JAVA_HOME）tomcat主动寻找的配置变量
		3. 下载解压后mavenjar包   
		4. 配置 maven的环境变量，因为maven也是需要在电脑中进行使用，任何地方都可以获取对应的maven的命令
		5. MAVEN_HOME (对应的安装路径即可bin之前目录)
 
 6. 验证是否maven的环境变量和jdk的环境变量是否已经确定安装好
 7. cmd 窗口 mvn -v ---->如果出现相关的配置即可，下面是对应的配置的信息
 
 
maven工程的目录结构：
 
	1. 作为一个maven工程，它的src目录和pom.xml文件是必备的，进入到src的目录后如下2
 

 2. src目录下的文件结构如下，如果没有齐全，需要自己进行补齐文件的配置
 
						src/main/java:    存放项目编写java的文件，.java文件
						src/main/resources:    存放项目的资源文件，类似于一些配置文件等
						src/test/java:      存放所有单元测试.java文件，如 Junit的测试类
						target:   项目输出的位置，编译后的 .class文件会输出到这个目录，跟calsspath目录一样
						pom.xml: maven工程项目的核心配置文件，也就是坐标文件的配置等
 
 
maven中已经集成依赖了相关的tomcat的运行包：低版本 tomcat6
 
提供冲突的处理异常的机制：对于作用域的控制，进行何时及逆行使用，不适用进行更改，作用域。
作用域的控制类型主要有这么几个：
		  主要时因为jar的冲突的范围，如果同一个文件类型存在两个版本的jar包的话，就会有选择的障碍，不知道寻找那个jar的存在
		test    :测试中起作用
		provide ： 编译和测试的时候起作用
		runtime  ：只在测试，运行的时候起作用
		compile  ：编译，测试，运行的时候起作用
		system  ：编译，测试的时候起作用
 
tomcat不能编译jsp的原因有两个
 1. jar包的冲突
 2. 低版本的tomcat不能编译适配高版本的jdk
 发送到服务器的文件编译：
 1. jsp文件是被发送到tomcat服务器中，tomcat服务器进行翻译成servlet的文件，servlet再次被jdk进行编码成二进制的文件
 2. maven中的自带的tomcat6大幅度的不能支持高版本jdk编写的jsp文件，造成栈溢出，不能编译成功的原因
 3. jsp文件是被发送到tomcat中进行编译的，所以 当服务器的500错误的时候，就是服务器的问题，服务器不能进行编译，tomcat有问题。
 4. maven自带的tomcat的存在目录的文件下：通过查找对应的主机引擎 tomcat-catalina引擎的确定的版本，可以直接删除中央仓库中自带的tomcat6，下载高版本（最高7）的问题，那么便不会存在其他的问题，下次进行执行的时候使用的默认版本，本地仓库中自己添加的版本 tomcat7.x版本，可以解决很多问题
 5. tomcat6 jdk5
 6. tomcat7 jdk6+
 7. tomcat8 jdk7+
 8. tomcat9 jdk8+
 
 
maven的插件的集成过程：
 1. 安装好maven工具已经安装好：
 tomcat插件的集成：maven中默认集成的是tomcat6的版本，特别注意的是目前的中央仓库中并没有提供tomcat8的插件，也就是在中央仓库中最高的插件时 tomcat
 
 
 
 org.apache.tomcat.maven
 tomcat7-maven-plugin 中央仓库中存在的tomcat的插件，如果没有提示那么就表示中央仓库没有或者本地仓库没有约束指定
 2.1 tomcat的版本
 自定义配置的标签
 80 指定端口
 
 
  /mgr
  指定虚拟访问的路径
 UTF-8 防止中文乱码，指定tomcat的编码集标识
 tomcat7 自定义tomcat的名字的指定