IntelliJ IDEA 的使用方法总结

创建普通 Java 项目

1、首次新建一个项目

如果是首次使用，在这个界面可以点击 Create New Project ，创建一个新项目。

选择Java，然后选好 JDK 的位置，接着点击下一步 Next。

接下来不选择模板创建，直接点下一步，然后填写上项目名和项目保存的地址。

会提示目录不存在，直接点击OK创建。

这样一个Java 项目就建好了。

2、再次新建一个项目

如果想要再次新建一个项目，可以在 File ---> New ---> Project... 打开了新建项目的窗口，选择相应的项目，不过第二次就不需要选择JDK了，IDEA已经为你默认选择了上次的JDK。

选择新建后，接着会提示你新项目是要在当前窗口显示还是新开一个窗口显示，如果选择当前窗口显示，就会覆盖当前项目，因为IDEA一个窗口只显示一个项目。

3、再次打开一个项目

（1）如果想要再次打开一个项目，可以 File ---> Open... 然后选择你的项目，直接打开就行。

（2）也可以选择 File---> Open Recent ，选择打开一个最近打开过的项目。

界面按钮功能说明

1、运行代码按钮

比如写了个main方法，运行的话直接点击左边的绿色三角标志：

可以选择直接运行，也可以Debug运行，还可以对代码覆盖率进行测试（第三项这个不是太明白）。

2、侧边栏各功能窗口的开关控制

IDEA 界面左下角有一个控制各个界面开关的按钮

这个按钮点击可以控制各个侧边栏的开关，侧边栏里面有各个窗口的名称和对应的数字，使用 ALT + 数字 就能实现相应窗口的开关。

比如

或者鼠标直接放该按钮上去可以看到相应的窗口列表，点击也可进行相应窗口的开关操作。

3、项目窗口里的四个按钮

（1）修改项目包结构

通过Project窗口的一个小齿轮，可以选择是否隐藏空包来控制空包的合并显示还是展开显示。

类似于eclipse中的这个功能。

（2）显示项目中文件位置

这个按钮能显示当前类或者文件在项目结构中的位置。类似于eclipse中的

（3）收起项目结构

（4）收起项目窗口

创建 Java Web 项目

File ---> New ---> Project... 打开了新建项目的窗口。

通过 Java 或者 Java Enterprise 都可以创建 Java Web 项目。如下图所示：

填写上你的项目名称就可以了。

接着会提示你新项目是要在当前窗口显示还是新开一个窗口显示，同样选择新开一个窗口。

建好后的项目结构：

配置 Tomcat 服务器

有两个地方可以配置，如下图所示：

接下来点击 + 号，新建一个 本地的 Tomcat。

上图说的热部署只是静态资源的热部署，jsp之类的，如果想要修改class也实现热部署，需要把那两个选项设置为：“Update classes and resources”，不过不建议这么做，改动太频繁的话部署会出问题。

Application server 的 Configure 如下图所示：

接着设置部署的项目，在 Deployment 中点击 + 号，然后点击 Artifact... ，添加项目。

注意：Application context 选项为上下文根目录，也就是访问的时候的根目录，一般这里可以设置成 / ，这样访问的时候就不需要带上项目名（也就是这里指定的java_web_01_war_exploded）了。

接下来就会在 Application Servers 的窗口中看到配置好的 tomcat 以及部署好的项目。左侧的两个绿色的按钮分别是启动和DeBug启动。

接下来启动一下，启动成功，如下图所示：

如果部署出错，可以检查下Tomcat日志，级别默认是waring，修改成all就能看到所有日志了。

访问路径：http://localhost:8080/java_web_01_war_exploded/

自动会访问 index.jsp。

创建 Maven 项目

同样也是 File ---> New ---> Project... 打开了新建项目的窗口。

这里我们还是通过模板快速创建 Maven 项目，和 eclipse 的类似。

接下来我们填写好图中所示的三项内容。其中 ArtifactId 是坐标地址，一般默认是项目名。

接下来是选择maven，可以使用idea自带的，也可以使用我们自己安装的，一般都是使用我们自己安装的maven。

这里填好项目名，和上面的 ArtifactId 相比上了一个“-”，一般要设置相同，可以自己修改下。

接下来还是会询问你新项目是要在当前窗口显示还是新开一个窗口显示，同样选择新开一个窗口。

接下来Idea会给我们按照模板创建 maven 项目，同时右下角会有一个小弹窗。我们选择自动导入。

建好后的maven项目结构如下所示：

这时候会发现缺少resources目录，main 右键添加 Directory ，添加 resources 目录。

添加完后需要在 resources 上右键，选择将该目录作为资源根目录。

test 目录同样操作添加 resources 目录，然后指定该目录为测试资源的根目录。

都完成后项目结构是这样的：

可以在右侧边框中找到 Maven ，点击可以打开窗口，里面有一些maven命令，可以执行相应的操作。

还可以在 DEpendencise 中查看依赖的包。

clean：清除target下的内容

validate：

compile：编译

test：测试

package：打包

verify：

install：

将当前项目打包发布到maven库，比如把maven-01项目发布到maven库，则其他项目就能依赖该项目了，例如可以直接通过在maven-02的pom中添加下面依赖，则就能在maven-02中调用maven-01中的方法了。

   <dependency>
      <groupId>com.test.maven</groupId>
      <artifactId>maven-01</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>

同时可在依赖项中看到该包

site：

deploy：

创建 Junit 测试

（1）新建一个类

package com.test.maven;

public class Beat {
    public String getStr() {
        return "www";
    }
}

在该类中方法上使用 Ctrl + Shift + T 打开测试小窗口。创建一个新的测试。

写上测试类的类名。

就在测试目录里生成了测试类，

package com.test.maven;

import org.junit.Test;

import static org.junit.Assert.*;

public class BeatTest {

    @Test
    public void getStr() {
    }
}

完整的测试类代码：

package com.test.maven;

import org.junit.Test;

import static org.junit.Assert.*;

public class BeatTest {

    @Test
    public void getStr() {
        Beat beat = new Beat();
        String str1 = beat.getStr();//实际值
        String str2 = "ccc";//期望值
        assertEquals(str1, str2);//断言
    }
}

执行该测试代码，可以使用 junit 执行，也可以使用 maven 提供的 test 命令执行。

（2）下面是 junit 的测试结果，可以看出，代码执行结果出错了。

（3）下面是maven的test命令执行结果。

（4）完整项目结构：

（5）该项目的pom.xml，idea 自动生成的，我没进行修改：

<?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>com.test.maven</groupId>
  <artifactId>maven-01</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>maven-01</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

可以把多余的东西都删除了，方便配置自己的东西：

<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>com.test.maven</groupId>
  <artifactId>maven-01</artifactId>
  <version>1.0-SNAPSHOT</version>

</project>

创建maven web项目

不同之处是这里选择原型项目时选这个。

建完项目之后修改pom文件，删除不用的内容，注意留下一个war包设置，这里和上面普通maven项目的pom不一样。会发现多了个<packaging>war</packaging>

<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>com.test.maven</groupId>
  <artifactId>maven-03</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

</project>

接着和上面一样，补全目录结构，在main和test下面分别添加缺少的java和resources目录，然后还需要修改下web.xml的版本。

这样就差不多了。

为了将编译环境修改为指定java版本，需要添加编译插件，修改完的pom如下

<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>com.test.maven</groupId>
  <artifactId>maven-03</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
      <plugins>
        <!--编译插件-->
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <!--插件版本-->
          <version>3.8.0</version>
          <!--编译级别-->
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
            <!--编码格式-->
            <encoding>UTF-8</encoding>
          </configuration>
        </plugin>
      </plugins>
  </build>
</project>

最终的项目结构：

多模块管理创建项目

使用idea创建项目，每创建一个就需要打开一个窗口，如果项目多了很不方便，打开的窗口太多，不好切换。

所以idea还有一种模式，类似于eclipse的那种，一个窗口显示多个项目。不过idea叫做创建module。

先创建一个空项目，类似于eclipse的一个工作空间，然后在这个空项目（打开的窗口中）创建module，和创建项目的过程一模一样。

然后打开新窗口，在新窗口中创建Module，过程和之前创建项目的过程一模一样，不做重复了。

Maven工程的父子继承

新建一个module（注意是maven java项目），作为父项目。修改pom文件，然后把java目录和test目录都删除，只留一个pom.xml文件（父项目只有个pom）。

<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>com.wkcto.maven</groupId>
  <artifactId>maven-01</artifactId>
  <version>1.0.0</version>

  <!--Maven父工程的packaging标签值必须为pom-->
  <packaging>pom</packaging>

</project>

然后再新建一个module（注意是maven java项目，并且名称不要和父项目重复）：

建完之后会发现子项目的pom是这样的：

<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">
    <!--当前子工程的父工程-->
    <parent>
        <artifactId>maven-01</artifactId>
        <groupId>com.wkcto.maven</groupId>
        <version>1.0.0</version>
        <relativePath>../maven-01/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven-java-01</artifactId>

</project>

然后同样方法再新建一个module（注意是maven web项目，并且名称不要和父项目重复），pom如下，多了个war包：

<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">
    <parent>
        <artifactId>maven-01</artifactId>
        <groupId>com.wkcto.maven</groupId>
        <version>1.0.0</version>
        <relativePath>../maven-01/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven-web-01</artifactId>
    <packaging>war</packaging>

</project>

最后modules结构如下：

子工程继承父工程的pom文件后，会无条件的继承父工程的依赖。也会无条件继承父工程的插件。

这样就会导致一个问题，那就是会把一些无用的包继承过来，增加了部署风险。

所以增加了一个<dependencyManagement>标签，用于管理依赖，这时在子项目pom中只需要依赖相应的包，不需要写版本号了，版本号直接继承自父项目。也就是相当于父项目只管理了版本号。当然，子项目中也可以定义自己依赖包的版本号，会直接覆盖父项目中定义的该依赖包的版本号。

父项目最后pom结构示例如下，可参考：

<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>com.wkcto.maven</groupId>
  <artifactId>maven-01</artifactId>
  <version>1.0.0</version>

  <!--Maven父工程的packaging标签值必须为pom-->
  <packaging>pom</packaging>

  <properties>
    <!--自定义标签来描述依赖的版本号-->
    <junit-versition>4.11</junit-versition>
    <mysql.versition>5.1.38</mysql.versition>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit-versition}</version>
        <scope>test</scope>
      </dependency>

      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.versition}</version>
      </dependency>
    </dependencies>
  </dependencyManagement>

</project>

子项目pom：

<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">
    <!--当前子工程的父工程-->
    <parent>
        <artifactId>maven-01</artifactId>
        <groupId>com.wkcto.maven</groupId>
        <version>1.0.0</version>
        <relativePath>../maven-01/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven-java-01</artifactId>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <!--默认继承的是父工程的版本号，当然也可以自己定义-->
        </dependency>
    </dependencies>

</project>

<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">
    <parent>
        <artifactId>maven-01</artifactId>
        <groupId>com.wkcto.maven</groupId>
        <version>1.0.0</version>
        <relativePath>../maven-01/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven-web-01</artifactId>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--默认继承的是父工程的版本号，当然也可以自己定义-->
        </dependency>
    </dependencies>

</project>

IDEA中SpringBoot项目使用热部署插件

首先在pom中引入插件依赖

        <!-- SpringBoot开发自动热部署插件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency> 

之后项目启动状态下做完修改后，直接选中项目，点击Build，选中项目选项（为的是进行全局编译），项目就会重启的。

IDEA中修改代码警告级别

比如在 Service 中注入一个 Mapper，IDEA工具自己检查会显示红色错误提示：

但是这并不是个错误，只是工具自己的校验提示找不到这个bean，其实不影响程序运行，为了美观一点，我们可以修改下这里的警告级别。

点左边的红色灯泡，下拉选择第一项，然后再选第一项，如图所示：

可以把这处错误修改成警告：

IDEA中添加序列化ID

File ----- Setting 中的检查项设置 Inspections，然后在右侧窗口找到Java下的 Serialization issues，对其中的 Serializable class without 'serialVersionUID' 选项打上对勾，设置为警告。

然后就能看到序列化的类会提示没有序列化ID，可以自动生成

选中类名，Alt + Enter 添加序列化ID。

添加成功。