黑马就业班（02.JavaWeb+项目实战\05.Tomcat+06.Servlet和HTTP）——Tomcat服务器（在IDEA中创建与使用JavaEE项目）+Servlet基础

今日内容

1. web相关概念回顾
2. web服务器软件：Tomcat
3. Servlet入门学习

1、web相关概念回顾
1） 软件架构

1. C/S：客户端/服务器端
2. B/S：浏览器/服务器端

2）资源分类

1. 静态资源：所有用户访问后，得到的结果都是一样的，称为静态资源.静态资源可以直接被浏览器解析
	* 如： html,css,JavaScript
2. 动态资源:每个用户访问相同资源后，得到的结果可能不一样。称为动态资源。动态资源被访问后，需要先转换为静态资源，在返回给浏览器
	* 如：servlet/jsp,php,asp....

3） 网络通信三要素

1. IP：电子设备(计算机)在网络中的唯一标识。
2. 端口：应用程序在计算机中的唯一标识。 0~65536
3. 传输协议：规定了数据传输的规则
	1. 基础协议：
		1. tcp:安全协议，三次握手。 速度稍慢
		2. udp：不安全协议。 速度快

  这一部分见视频2的解析。

2、web服务器软件
  相关概念（这一部分见视频3的解析，很重要！）

* 服务器：安装了服务器软件的计算机
* 服务器软件：接收用户的请求，处理请求，做出响应（比如MYSQL服务器，Web服务器）
* web服务器软件：接收用户的请求，处理请求，做出响应。
	* 在web服务器软件中，可以部署web项目，让用户通过浏览器来访问这些项目（如使用HTML，CSS，JS编写的静态项目，或者是使用Servlet/jsp编写的动态项目）
	* web容器（静态资源可以独立运行，而动态资源不能独立运行，它必须依赖于服务器软件，也就是说，动态资源的运行需要依赖服务器软件，如Servlet类的运行必须依赖Tomcat服务器）
	* web容器是一种服务程序，在服务器一个端口就有一个提供相应服务的程序，而这个程序就是处理从客户端发出的请求，如JAVA中的Tomcat容器，ASP的IIS或PWS都是这样的容器。一个服务器可以有多个容器。（既Tomcat服务器就是一种web服务器，也是一种web容器）

  常见的java相关的web服务器软件：

* webLogic：oracle公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
* webSphere：IBM公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
* JBOSS：JBOSS公司的，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
* Tomcat：Apache基金组织，中小型的JavaEE服务器，仅仅支持少量的JavaEE规范，如servlet/jsp规范。开源的，免费的。

  JavaEE：Java语言在企业级开发中使用的技术规范的总和，一共规定了13项大的规范。

Tomcat：web服务器软件

  Tomcat（服务器软件）相应的使用步骤如下：（我们使用的是Tomcat8）

1. 下载：http://tomcat.apache.org/
2. 安装：解压压缩包即可。
	* 注意：安装目录建议不要有中文和空格
3. 卸载：删除目录就行了
Tomcat安装包的目录结构（我们以后学习的Apache的项目基本上都是这个结构）：参考视频4以及下面的图片。重要的是webapps项目，用来存放web项目，里面包含Tomcat自带的项目以及我们自己创建的项目。

4. 启动：
	* bin/startup.bat ,双击运行该文件即可（Linus系统启动双击startup.sh文件）
	* 访问：浏览器输入：http://localhost:8080或者是http://127.0.0.1:8080 回车访问自己（会看到Tomcat自带的一个页面）
					  http://别人的ip:8080 访问别人得Tomcat服务器（对方的服务器（电脑）必须启动了Tomcat软件）
	* 在cmd中使用ipconfig命令可以查看自己的ip地址（IPv4地址）
	
	* 可能遇到的问题：
		1. 黑窗口一闪而过：
			* 原因： 没有正确配置JAVA_HOME环境变量（Tomcat服务器软件是java编写的，它的启动和运行必须依赖于电脑安装的JDK，因此必须正确配置java环境变量，否则Tomcat找不到JDK）
			* 解决方案：正确配置JAVA_HOME环境变量

		2. 启动报错：（错误信息在logs日志文件夹下catalina.日期.log文件查找）
			1. 暴力：找到占用的端口号，并且找到对应的进程，杀死该进程。
				查找占用各类端口的进程的命令如下，我们只需要查找8080端口对应的PID（进程ID），随后启动任务管理——进程——详细信息，就可以找到PID对应的进程（按PID排序可以简单查找到），然后将进程结束即可。
				* netstat -ano
			2. 温柔：修改自身的端口号（Tomcat默认端口号是8080），需要修改下面这些端口号，这样就可以启动2个Tomcat，因为他们占用的端口不一样。（先启动一个再修改）
				* conf/server.xml文件
				* <Connector port="8080" protocol="HTTP/1.1"
	               connectionTimeout="20000"
	               redirectPort="8443" />
	               <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
	               <Server port="8005" shutdown="SHUTDOWN">
	               
				* 一般会将tomcat的默认端口号修改为80。80端口号是http协议的默认端口号。（目前还是使用8080，不要修改端口号）
					* 好处：在访问时，就不用输入端口号（比如我们访问一些http协议的网址的时候，由于他们服务器的端口是80，而http协议默认访问80端口，就不需要输入端口号）
					
5. 关闭：
	1. 正常关闭：
		* bin/shutdown.bat
		* ctrl+c
	2. 强制关闭：
		* 点击启动窗口的×（强制关闭有可能各类文档没有保存成功）
（后期一般都是结合java使用服务器，会在IDEA等集成环境中开启关闭）

6. 配置:
	* 部署项目的方式（3种）：
		1. 直接将项目放到webapps目录下即可。
			* /hello：项目的访问路径-->虚拟目录（和项目的实际存放的路径是一样的）
			如：将hello文件夹（含hello.html）放到webapps下，可以使用：ip地址:8080/hello/hello.html访问，就可以访问到hello.html文件
			* 简化部署：将项目打成一个war包，再将war包放置到webapps目录下。
				* war包会自动解压缩
			如：hello文件夹下有很多个文件（这里使用hello.html代替），拷贝很慢，可以将这些文件压缩为zip，再将后缀修改为war（最好使用专业的war的打包工具，它与zip打包很类似），这样传输很快，而且我们如果将war包放到webapps文件夹下，会自动解压缩成为一个hello文件夹，里面包含hello.html文件。并且后期我们想删除项目，可以直接将war包删除，文件夹也会自动删除。
			* 缺点：方法1不管怎么样都需要将文件或者war拷贝到webapps下，比较麻烦。我们通过下面方法的配置，可以不用将文件放到webapps下也可以访问到。
	
		2. 配置conf/server.xml文件
			在<Host>标签体中配置
			<Context docBase="D:\hello" path="/hehe" />
			* docBase:项目存放的路径（docBase是指项目实际存放的路径）
			* path：虚拟目录（path是指我们使用浏览器访问项目时所要指定的路径）
		如：我们在访问G盘hello文件夹下hello.html文件的时候，必须访问虚拟路径：http://127.0.0.1:8080/hehe/hello.html
		重要！！！：注意，在设置docBase的时候，由于设置的是window下的实际的文件夹，因此必须要使用反斜杠“\”，但是在设置path的时候，它是浏览器通过网络访问访问的项目，涉及网络，使用斜杆“/”。
		* 缺点：server.xml是Tomcat的核心，配置这个文件有可能损坏Tomcat。一般不会在servel.xml配置文件
	
		3. 在conf\Catalina\localhost创建任意名称的xml文件。在文件config.xml中编写
			<Context docBase="D:\hello" />
			* 虚拟目录：xml文件的名称
		访问：http://127.0.0.1:8080/config/hello.html
		这种方式是一种热部署的方式，我们如果在server.xml配置，需要关闭重启服务器才能生效，而在这里只需要修改配置的文件夹即可生效。
		需要注意，每个项目都会有自己的server.xml与conf\Catalina\localhost，而Tomcat有自己总的server.xml与conf\Catalina\localhost。我们修改的时候要修改对应项目的相关配置文件。
	

  项目分类

* 静态项目和动态项目：静态项目只能存放静态资源（html，JS，CSS，图片，文本等），动态项目既可以存放动态资源（Servlet，jsp等），也可以存放静态资源。
	* 目录结构
		* java动态项目的目录结构：（含有WEB-INF目录的项目就是动态项目）
		-- 项目名称
			-- src目录（存放java文件）
			-- 项目的根目录（一般是web）
				-- 项目的静态资源
				-- WEB-INF目录：
					-- web.xml：web项目的核心配置文件
					-- classes目录：放置字节码文件的目录
					-- lib目录：放置依赖的jar包
		* java静态项目的目录结构：
			-- 项目的根目录
				-- 项目的静态资源

  将Tomcat集成到IDEA中，并且创建JavaEE的项目，部署项目（见视频9解析）。

  上面是我们创建的Web项目的目录，其中web是根目录，下面没有静态资源（后期静态资源放在web目录下），但是有Web-INF文件夹（用来存放Web动态资源），里面有web.xml配置文件（后期会有classes文件夹以及libs文件夹）。而src用来存放相应的java代码。对于index.jsp，目前只需要将其看做一个普通的HTML文件即可。
  每次使用完Tomcat服务器之后最好关闭，否则这个Tomcat进程可能一直占用某些端口，导致后面没办法启动，还要我们手动清理这些端口的进程。
  系统会默认访问web目录下的文件（虚拟目录设置为“/”），因此我们在访问的时候，直接将静态资源放到web文件夹下面，就可以直接访问到，不需要指定web。如访问：http://127.0.0.1:8080/index.jsp 可以访问到，而访问http://127.0.0.1:8080/web/index.jsp就出错。再比如在web文件夹下放一个hello.html，直接访问：http://127.0.0.1:8080/hello.html 会出错，但是重启服务器，再次访问就可以访问到。（每次访问都要重启服务器很麻烦，后面会讲到热部署）
  热部署：Run-Edit configuration-Tomcat Server-Server，将On Update action与On frame deactivation都修改为Update resource，这样以后修改静态资源后就不需要重启Tomcat服务器。

  关于怎么使用导入的JavaEE项目，可以参考自己的文章：《如何配置IntelliJ IDEA创建并发布JavaEE项目？》，里面描述地很详细。

3、Servlet入门学习
  Servlet(Server Applet)概念：运行在服务器端的小程序（视频10的解析）

* Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat识别)的规则。
* 将来我们自定义一个类，实现Servlet接口，复写方法。

  为了使得浏览器访问动态资源的时候获得的数据不一样，我们必须使用java来设置，也就是说，浏览器请求动态资源的时候，会找java类，由java类来为其调度动态资源。而这种java类没有main方法，必须依赖于服务器才能运行，相当于是Tomcat服务器软件在执行它。而为了使得Tomcat能识别这些调度动态资源的java类，这些java类必须遵循一定的规则，这里所说的规则，其实就是Servlet。

• 注意，JavaEE的类需要查询JavaEE对应的API。
  

• 快速入门：

1. 创建JavaEE项目
2. 定义一个类，实现Servlet接口
	* public class ServletDemo1 implements Servlet
3. 实现接口中的抽象方法
4. 配置Servlet。
为什么要配置：视频11-3.00。我们浏览器需要通过url来访问实现Servlet的java类，比如：localhost:8080/lkj_Tomcat（虚拟目录）/demo1（类的资源路径），那么我们必须通过配置文件将实际的java类的实际路径映射为资源路径，然后浏览器才能通过虚拟路径访问到java类。
	 在动态资源目录WEN-INF下的web.xml文件中配置，配置的内容必须要放在<web-app>标签之内：
    <!--配置Servlet -->
    <servlet>
        <servlet-name>demo1</servlet-name>
        <!--java类的实际路径：全类名-->
        <servlet-class>cn.itcast.web.servlet.ServletDemo1</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>demo1</servlet-name>
        <!--java类的资源路径：通过浏览器访问这个类的时候输入的路径-->
        <url-pattern>/demo1</url-pattern>
    </servlet-mapping>

  配置完成之后，我们启动服务器，然后在Output输出栏右键Clean all，清除所有内容。然后下面和访问静态资源的方式一样，我们这里是通过java类来访问动态资源，在浏览器输入：http://localhost:8080/demo1，回车发现浏览器没有显示什么，但是Output输出栏显示：hello servlet ，也就是说，ServletTest1的service方法在浏览器访问的时候都会被调用一次。
  下面是相关代码

//ServletTest1：这个类没有Main方法，是由Tomcat服务器控制的
import javax.servlet.*;
import java.io.IOException;

/**
 * Servlet快速入门
 */
public class ServletTest1 implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    //提供服务的方法
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("Hello Servlet");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {    }
}

  

<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">

    
    <servlet>       
        <servlet-name>demo1servlet-name>      
        <servlet-class>TomcatDemo.ServletTest1servlet-class>      
    servlet>

    <servlet-mapping>       
        <servlet-name>demo1servlet-name>
        <url-pattern>/demo1url-pattern>
    servlet-mapping>

web-app>

• 执行原理（视频12解析，这一部分也比较重要）

1. 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径；
2. 查找web.xml文件，是否有对应的<url-pattern>标签体内容；
3. 如果有，则在找到对应的<servlet-class>全类名；
4. tomcat会将字节码文件加载进内存，并且创建其对象（Class.forName(全类名)，获取类的Class对象，Class对象.newInstance()，创建类的实例）；
5. 调用其service方法执行资源的调度；

• 补充：
    前面我们提到，将项目的虚拟目录设置为“/”，我们在访问的时候就可以不用写项目名称的虚拟目录，比如访问lkj_Tomcat项目下的ServletTest1类（该类名的映射是demo1），我们可以简写为：http://localhost:8080/demo1。
    但是后期项目多了，这样设置显然不合适，我们可以在Run-Edit configuration-Tomcat Server-Deployment下的Application Context下，将项目名称的虚拟目录添加上，为：/项目名（项目名与虚拟目录名称相同），/lkj_Tomcat （当然，这里必须重启Servlet才会生效）。这样，我们再想访问lkj_Tomcat项目的demo1的时候，就不能省略项目名，从而区分各个项目的各个类。必须写作：http://localhost:8080/lkj_Tomcat/demo1 。（后期都要将虚拟目录添加上！！！）
  

Servlet中的生命周期方法

  Servlet的5个方法的解析如下（见视频13解析）。记得每创建一个新的Servlet类，都必须要为该类配置servlet.xml文件，为该类的类名提供映射，方便浏览器访问的时候能找到他。

package TomcatDemo;

import javax.servlet.*;
import java.io.IOException;

/**
 * Servlet的方法
 */
public class ServletTest2 implements Servlet {
    private int age = 3;

    /**
     * 初始化方法
     * 在Servlet被创建时，执行。对于每个Servlet，init()只会执行一次
     * @param servletConfig
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("init.....");
    }

    /**
     * 获取ServletConfig对象
     * ServletConfig：Servlet的配置对象
     * @return
     */
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    /**
     * 提供服务方法
     * 每一次Servlet被访问时，执行。执行多次
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service.....");
        int number = 3;
    }

    /**
     * 获取Servlet的一些信息，版本，作者等等。。
     * @return
     */
    @Override
    public String getServletInfo() {
        return null;
    }

    /**
     * 销毁方法
     * 在服务器正常关闭时，执行，执行一次。
     */
    @Override
    public void destroy() {
        System.out.println("destroy.....");
    }
}

/*
结果：
init.....
service.....  //第一次访问Servlet的demo2类，init()被调用，同时service()被调用
service.....
service.....
service.....
service.....  //后面多次访问Servlet的demo2类，只有service()被调用
destroy.....  //关闭服务器，destroy()被调用
 */

  Servlet的生命周期如下：

1. Servlet被创建：执行init方法，只执行一次（Servlet只会被创建一次）。那么Servlet什么时候被创建？
	* 默认情况下，第一次被访问时，Servlet被创建
	* 可以配置执行Servlet的创建时机。
		* 在web.xml配置文件的<servlet>标签下配置
			1. 第一次被访问时，创建（既用户第一次调用对应于该 Servlet 的 URL 时）
              		* <load-on-startup>的值为负数
            2. 在服务器启动时，创建
                * <load-on-startup>的值为0或正整数

	* Servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个Servlet对象，Servlet是单例的。既当用户开启一个 Servlet 时，就会创建一个 Servlet 实例，后面用户可能向这个Servlet发送多个请求，也可能有多个用户访问这个Servlet，但是在后续每次用户请求Servlet时不再调用init()方法，但是每一个用户请求都会产生一个新的线程，适当的时候移交给 doGet 或 doPost 方法。也就是说，一个Servlet实例可能接收多个用户请求（请求可能来自不同的用户），从而这个Servlet服务被多线程访问，但是Servlet只会初始化init()一次。
		* 多个用户同时访问时，可能存在线程安全问题。（不能加锁，加锁会对性能产生较大的影响）
		* 解决：尽量不要在Servlet中定义成员变量。即使定义了成员变量，也不要对修改值

2. 提供服务：执行service方法，执行多次
	* 每次访问Servlet时，Service方法都会被调用一次。

3. 被销毁：执行destroy方法，只执行一次
	* Servlet被销毁时执行。服务器关闭时，Servlet被销毁
	* 只有服务器正常关闭时，才会执行destroy方法。（像之前点×关闭窗口强制关闭，destroy不会执行）
	* destroy方法在Servlet被销毁之前执行，一般用于释放资源（destroy() 方法可以让您的 Servlet 关闭数据库连接、停止后台线程、把 Cookie 列表或点击计数器写入到磁盘，并执行其他类似的清理活动。）。destroy释放完资源之后，servlet 对象被标记为垃圾，被JVM回收。

  修改init()方法执行时机的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">
<!---->
    <servlet>
        <servlet-name>demo2</servlet-name>
        <servlet-class>TomcatDemo.ServletTest2</servlet-class>

        <!--
        修改Servlet的创建时机
         1.第一次被访问时，创建
                * <load-on-startup>的值为负数
        2.在服务器启动时，创建
            * <load-on-startup>的值为0或正整数
        -->
        <load-on-startup>1</load-on-startup>
        <!--
        配置为0或正整数后，发现启动服务器init()就被调用，而等到我们访问demo2类的时候，service才会被调用
        之前启动服务器init()不会被调用，等到访问Servlet的demo2的时候，2个方法被同时调用
        -->

    </servlet>

    <servlet-mapping>
        <servlet-name>demo2</servlet-name>
        <url-pattern>/demo2</url-pattern>
    </servlet-mapping>

</web-app>

Servlet生命周期可以参考下面2篇文章
添加链接描述
添加链接描述

Servlet3.0

   好处：支持注解配置。可以不需要web.xml了（当然也可以使用web.xml配置）。之前我们每一次写一个Servlet类就要配置一次，相当麻烦。（从JavaEE6开始就支持servlet3.0）
  步骤：

1. 创建JavaEE项目，选择Servlet的版本3.0以上，可以不创建web.xml（不勾选创建web.xml，如下图）
2. 定义一个类，实现Servlet接口
3. 复写方法
4. 在类上使用@WebServlet注解，进行配置（第四步与前面不一样）
	* @WebServlet("资源路径")：
	* 虚拟目录：是项目的别称，既浏览器访问项目的方式
	* 资源路径：我们所访问的Servlet类的别称，既浏览器访问这个类的方式

  下面是注解@WebServlet的源码

	@Target({ElementType.TYPE})
	@Retention(RetentionPolicy.RUNTIME)
	@Documented
	public @interface WebServlet {
	    String name() default "";//相当于，在这里不需要配置，取默认值
	
	    String[] value() default {};//代表urlPatterns()属性配置
	
	    String[] urlPatterns() default {};//相当于，是数组，表示我们可以配置多个路径
	
	    int loadOnStartup() default -1;//相当于
	
	    WebInitParam[] initParams() default {};
	
	    boolean asyncSupported() default false;
	
	    String smallIcon() default "";
	
	    String largeIcon() default "";
	
	    String description() default "";
	
	    String displayName() default "";
	}

  下面是我们的Servlet3.0的测试代码

package lkj.Tomcat;

import javax.jws.WebService;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;

//我们事先要将当前项目的虚拟目录名称（与项目名称相同）lkj_tomcat配置好，这样访问当前类的时候就需要把项目名称带上:/lkj_tomcat

//不需要再配置web.xml，使用@WebServlet注解即可
//我们这里使用这个注解，只需要配置urlPatterns一个参数即可（这里参考自己有关注解的文章来配置即可）
//@WebServlet(urlPatterns = {"/demo"}) //这里数组urlPatterns只有一个参数，可以省略{}，且其是字符串类型，需要加""。另外urlPatterns需要写为“/demo”

//另外，注解里面有一个很重要的属性：value，如果只有一个属性，那么在调用value的时候，value可以不写，直接写值
//其实在@WebServlet中，urlPatterns就是所谓的value，那么可以写成:urlPatterns = {"/demo"}、value = {"/demo"}、"/demo"3种形式
//@WebServlet({"/d1" , "/d2" , "/d3"}) //定义多个路径
@WebServlet(urlPatterns = "/demo2")//我们后期都是使用这种方式来调用
public class ServletTest implements Servlet
{
    @Override
    public void init(ServletConfig servletConfig) throws ServletException
    {    }

    @Override
    public ServletConfig getServletConfig()
    { return null;    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException
    {
        System.out.println("servlet3.0 run....");
    }

    @Override
    public String getServletInfo()
    { return null;    }

    @Override
    public void destroy()
    {    }
}
/*
结果：启动Tomcat，访问：http://localhost:8080/lkj_tomcat/demo
发现Output出现
init.....
servlet3.0 run....
既运行成功
 */

  以后我们都使用注解配置，而不使用web.xml配置文件配置。

IDEA与tomcat的相关配置

• 我们下面的讨论针对项目“G:\idea_java_project\java-demo1”下的“lkj_tomcat”模块（JavaEE项目）

1） IDEA会为每一个tomcat部署的项目单独建立一份配置文件

* 启动服务器，并查看控制台的server的Output窗口，有一行目录：Using CATALINA_BASE:   "C:\Users\Administrator\.IntelliJIdea2017.3\system\tomcat\_java-demo1"
这个文件夹里面保存的就是当前项目对于Tomcat的配置。我们可以在conf下的各个xml文件对项目配置进行修改，当然，也可以通过IDEA进行修改（这样比较方便）
在server.xml下修改Tomcat的端口；在Catalina-localhost下修改配置文件，我们发现我们在IDEA中将项目虚拟目录名改为“haha”，那么Catalina-localhost下的配置文件名对应改为“haha.xml”，这个“haha.xml”下的信息为：
<?xml version="1.0" encoding="UTF-8"?>
<Context path="/haha" docBase="G:\idea_java_project\java-demo1\out\artifacts\lkj_tomcat_war_exploded" />
path就是项目的虚拟目录，docBase就是项目的实际路径，既Tomcat服务器的项目路径，而不是本地工作空间路径（这里说的对应本文最上面6：项目的部属）

2）一个JavaEE项目有2个地方存储：工作空间项目 和 tomcat部署的web项目，这两个项目虽然是同一个项目。但是他们存储的位置不一样。
  所谓的工作空间，其实就是我们创建的Java项目的文件夹，比如对于JavaEE项目“lkj_tomcat”，我们之前创建的项目是“G:\idea_java_project\java-demo1”，其中java-demo1就是我们创建的项目名称，也叫做工作空间。而“lkj_tomcat”文件夹就是对应的JavaEE工作空间项目（也就是我们创建的Module），在java-demo1工作空间下，还有一个“out”文件夹，“G:\idea_java_project\java-demo1\out\artifacts”下有一个“lkj_tomcat_war_exploded”文件夹，这个文件夹就是 tomcat部署的web项目。
  “工作空间项目”下的src文件夹下的java文件被编译成为.class文件后，会被放到“tomcat部署的web项目”下的“WEB-INF\classes”文件夹处。

* tomcat真正访问的是“tomcat部署的web项目”，"tomcat部署的web项目"对应着"工作空间项目" 的web目录下的所有资源
* WEB-INF目录下的资源不能被浏览器直接访问。我们要把资源放到web目录下就可以，不要放到WEB-INF文件夹下，否则浏览器访问不到。

  我们前面说到的要在Project Structure中的Artifacts添加相应的项目的war exploded，其实就是添加tomcat部属的web项目，同时将这些war exploded添加到Deployment中（具体参考自己的文章）

3） 断点调试：使用"小虫子"启动 dubug 启动。同样是设置红色按钮来设置断点，但是调试不能再是按启动按钮，而是按小虫子按钮。