项目Github地址：https://github.com/zxuqian/Learning-Java-EE-2016

由于Eclipse在Mac下的表现并不好，严重影响效率，所以在添加JPA模块之前，先教大家如何把项目迁移到IntelliJ IDEA下。IntelliJ是一个非常强大的Java IDE，提供流畅的操作界面和智能的项目编译和运行管理，所谓intelligent。因为项目是按Maven的结构构造，所以即使换掉IDE也不用对项目做发动，只是需要删除一些Eclipse专用的文件而已。所以如果你用Windows或者想继续使用Eclipse的话，可以跳过本节。
另外由于在迁移之前，新的项目已经开发一半，所以会看到几个新项目，稍后会对其进行介绍。

迁移到IntelliJ

打开IntelliJ，在首页中选择 Import Project。

选择 Import project from external model 然后选择Maven 并点击 next.

选择 search for project recursively, 因为我们的项目是模块化，pom.xml在子文件夹下，所以我们需要递归查找子目录。再勾选 import Maven projects automatically。点击 next.

勾选搜索出来的项目： com.zxuqian:notebookRoot:0.0.1-SNAPSHOT, 此为所有Maven模块的根模块，用来统一管理依赖。稍后详细介绍。

选择 JDK 并点击 next。

给项目命名并选择项目文件存储目录，这里保持默认。点击Finish。

现在进入到IntelliJ主界面，会发现项目下存在Eclipse相关配置文件： .settings, build, .classpath, .project。这些可直接安全删除。

优化项目结构

Maven是一个强大的依赖管理和项目构建工具，并且pom.xml文件可以继承，以方便管理依赖的版本和定义通用的属性。
首先，创建一个新的maven模块，给定group id为com.zxuqian, artifact id为 notebookRoot, 版本为：0.0.1-SNAPSHOT。 此为其他所有模块的根模块，所以在此模块执行 maven clean 或 install 为所有子模块执行相同的操作。Pom.xml文件如下所示：

<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.zxuqian</groupId>
  <artifactId>notebookRoot</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>

  <dependencyManagement>
    <dependencies>
      <dependency>
          <groupId>org.wildfly.bom</groupId>
          <artifactId>wildfly-javaee7</artifactId>
          <scope>import</scope>
          <type>pom</type>
          <version>10.1.0.Final</version>
        </dependency>
    </dependencies>
  </dependencyManagement>
  
  <dependencies>

  </dependencies>
  <modules>
    <module>../notebook</module>
    <module>../notebookDomain</module>
    <module>../notebookEAR</module>
  </modules>
</project>

<packaging>此项目为pom形式，只用来提供pom.xml文件供子模块继承。
<dependencyManagement>_使用wildfly bom 来管理wildfly的依赖库。Wildfly bom也是一个pom类型的项目，其中定义了wildfly所有的依赖库。import scope 是说此pom继承自wildfly bom。这样做可以避免在每个模块的pom.xml中定义版本号，以免引起混乱。
<modules> 标签引用其他子模块，运行maven的目标也会在这些子模块中同时运行 notebookDomain 和notebookEAR 模块会在下面创建。

更新JSF模块

由于更新了项目结构，上次创建的JSF模块需要做一些改动，新的pom.xml文件：

<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.zxuqian</groupId>
  <artifactId>notebook</artifactId>
  <packaging>war</packaging>

  <parent>
    <groupId>com.zxuqian</groupId>
    <artifactId>notebookRoot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <relativePath>../notebookRoot/pom.xml</relativePath>
  </parent>
  
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.5.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.0.0</version>
        <configuration>
          <warSourceDirectory>WebContent</warSourceDirectory>
        </configuration>
      </plugin>
    </plugins>
  </build>
  <dependencies>
    <dependency>
      <groupId>org.jboss.spec.javax.faces</groupId>
      <artifactId>jboss-jsf-api_2.2_spec</artifactId>
      <scope>provided</scope>
    </dependency>
  </dependencies>
</project>

注意 <parent> 标签, 引用自notebookRoot根模块。 依赖更改为wildfly bom中提供的 org.jboss.spec.javax.faces.jboss-jsf-api_2.2_spec

安装 MySQL 数据库

请参考MySQL官方网站如何安装: https://dev.mysql.com/doc/refman/5.7/en/osx-installation-pkg.html
基本只需下载一个安装包，双击运行。这里用的版本为MySQL 5.7。

创建JDBC Resource

首先下载mysql jdbc 连接驱动: https://dev.mysql.com/downloads/connector/j/
解压缩下载的文件，其中 mysql-connector-java-5.1.40-bin.jar 即为驱动。
首次启动Wildfly之前需要添加用户才能登录管理界面，在命令行中运行：
/Users/zxuqian/development/tools/wildfly-10.1.0.Final/bin/add-user.sh
根据提示创建管理用户。
从命令行中启动Wildfly：
/Users/zxuqian/development/tools/wildfly-10.1.0.Final/bin/standalone.sh
登录到管理界面： http://localhost:9990

在欢迎界面点击Deploy an Application旁边的 start。我们需要先把MySQL的jdbc驱动部署到Wildfly。在随后出现的页面中，点击 Add 。

选择Upload a new deployment。点击Next。

选择解压得到的jar文件。点击Next。

保持默认，点击Finish。

回到首页，点击Create a datasource旁边的start链接。在随后出现的页面中选择 Subsystems -> Datasources -> Non-XA。点击右边的 Add。

选择MySQL datasource. 点击Next。

指定一个Datasource名称和JNDI名称。 JNDI 名称十分重要，会在JPA连接到JDBC Resource的时候用到。点击Next。

选择Detected driver并选择第一个检测出来的驱动。点击next。

定义连接 URL。这里我创建的数据库名称为notebook，在配置URL之前，先在mysql中使用“create database notebook”命令创建此数据库。指定MySQL用户名和密码之后，点击next。

查看配置概要，如果正确点击finish。

可通过下图的方式测试是否连接成功：

如果成功连接到数据库，会弹出下图提示框：

创建JPA module

从IntelliJ中创建一个Maven 模块。使用下图所示的groupId, artifactId, 并选择择之前所创建的notebookRoot做为父项目： com.zxuqian:notebookRoot:0.0.1-SNAPSHOT

创建完成后，修改pom.xml文件内容：

<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.zxuqian</groupId>
  <artifactId>notebookDomain</artifactId>
  <packaging>jar</packaging>
  
  <parent>
    <groupId>com.zxuqian</groupId>
    <artifactId>notebookRoot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <relativePath>../notebookRoot/pom.xml</relativePath>
  </parent>
  
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.5.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <dependencies>

    <dependency>
      <groupId>org.hibernate.javax.persistence</groupId>
      <artifactId>hibernate-jpa-2.1-api</artifactId>
      <scope>provided</scope>
    </dependency>

  </dependencies>
</project>

此模块打包为Jar项目，为Java EE所要求的JPA模块打包结构。
因为wildfly运行环境提供JPA实现，所以这里JPA依赖的scope为provided，仅在编译时提供。

创建一个 Entity

Entity是Java对象和数据库表建立关系的桥梁，使用JPA注解来配置如何生成对应的数据库表。首先创建一个class，类名为User，并填入如下代码：

package com.zxuqian.notebook.domain;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.*;

/**
 * Entity implementation class for Entity: User
 *
 */
@Entity
public class User implements Serializable {

    private static final long serialVersionUID = 1L;
    
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private long id;
    private String username;
    private String password;
    private Date dateOfBirth;
    private String email;
    private String phone;

    public User() {
        super();
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getDateOfBirth() {
        return dateOfBirth;
    }

    public void setDateOfBirth(Date dateOfBirth) {
        this.dateOfBirth = dateOfBirth;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
    
   
}

此类为POJO(simple plain old java bean)，意思为此类提供一组属性，并提供用这些属性初始化对象的构造方法，以及访问和设置这些属性的getter和setter方法。Entity需要实现Serializable接口以便JPA把对象序列化到数据库和从数据库中反序列化出来。
@Entity注解表明此类为Entity，默认使用类名作为表名。
@Id注解声明此成员变量为数据库中的主键，使用IDENTITY生成策略，即JPA负责生成ID的数值。
在src/META-INF 目录, 创建名为 persistence.xml 的文件，填入如下内容:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
    <persistence-unit name="notebookDomain">
        <jta-data-source>java:/MySqlDS</jta-data-source>
        <properties>
            <property name="javax.persistence.schema-generation.database.action" value="drop-and-create"/>
            <property name="javax.persistence.schema-generation.scripts.action" value="none"/>
        </properties>
    </persistence-unit>
</persistence>

此文件为JPA的配置文件。 <jta-data-source> 使用在wildfly下创建的JNDI名称。 javax.persistence.schema-generation.database.action 属性的值，drop-and-create ，表示数据库表会在每次项目部署后重新创建。 javax.persistence.schema-generation.scripts.action 表示是否生成SQL 文件。

创建EAR 模块

因为JSF模块和JPA模块为独立的两个项目，所以我们需要把它们打包成一个EAR包部署到wildfly服务器中。它包含的JSF和JPA模块会自动被wildfly识别并部署。创建此项目（groupId和artifacitId请参考下方pom文件），并在pom.xml中填入下方代码：

<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.zxuqian</groupId>
  <artifactId>notebookEAR</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>ear</packaging>
  
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-ear-plugin</artifactId>
        <version>2.10</version>
        <configuration>
          <earSourceDirectory>EarContent</earSourceDirectory>
          <version>7</version>
          <defaultLibBundleDir>lib</defaultLibBundleDir>
          <modules>
            <webModule>
              <groupId>com.zxuqian</groupId>
              <artifactId>notebook</artifactId>
              <contextRoot>/notebook</contextRoot>
            </webModule>
          </modules>
        </configuration>
      </plugin>

        <plugin>
            <groupId>org.wildfly.plugins</groupId>
            <artifactId>wildfly-maven-plugin</artifactId>
            <version>1.2.0.Alpha2</version>
            <configuration>
                <jbossHome>/Users/zxuqian/development/tools/wildfly-10.1.0.Final</jbossHome>
            </configuration>
        </plugin>

    </plugins>
  </build>
  
  <dependencies>
    <dependency>
      <groupId>com.zxuqian</groupId>
      <artifactId>notebook</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <type>war</type>
    </dependency>
    <dependency>
      <groupId>com.zxuqian</groupId>
      <artifactId>notebookDomain</artifactId>
      <version>0.0.1-SNAPSHOT</version>
    </dependency>
  </dependencies>
</project>

<webModule> 指定JSF模块为web模块，可定义context root，即访问项目的URL根路径。
这里使用了 wildfly-plugin 插件，可以方便的启动、关闭服务器，部署，卸载项目。在<jbossHome>中指定wildfly 主目录，否则它会自动下载一个新的wildfly以供使用。<denpendencies>指定了此项目编译需要依赖的模块，即JSF和JPA，它需要把这两个项目打包进EAR包。

运行应用

在IntelliJ中，点击View – Tool Windows – Maven Projects 来显示Maven视图：

双击notebookRoot的install来构建项目。双击notebookEAR下的wildfly:run来启动服务器并部署项目。如果需要重新部署项目，只需双击执行wildfly:redeploy即可。
验证数据库是否创建成功，请连接到MySQL数据库，并查看notebook数据库中是否存在User表。使用describe + 表名可显示表结构：

use notebook;
describe user;

如果看到如下结果即表示创建成功。