#springboot--IntelliJ IDEA+Springboot+hibernate+JPA（自动创建表）

1、配置pom.Xml

<?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.yzh.maven</groupId>
   <artifactId>hibernatespringbootjpapro</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>hibernatespringbootjpapro</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.4.0.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <tomcat.version>8.5.0</tomcat.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-jpa</artifactId>
      </dependency>

      <!-- oracle驱动包 -->
      <dependency>
         <groupId>com.oracle</groupId>
         <artifactId>ojdbc14</artifactId>
         <version>10.2.0.1.0</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>

         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <version>2.5</version>
            <configuration>
               <nonFilteredFileExtensions>
                  <nonFilteredFileExtension>jasper</nonFilteredFileExtension>
               </nonFilteredFileExtensions>
            </configuration>
         </plugin>
      </plugins>
   </build>

   <!-- Allow access to Spring milestones and snapshots -->
   <!-- (you don't need this if you are using anything after 0.5.0.RELEASE) -->
   <repositories>
      <repository>
         <id>spring-snapshots</id>
         <url>http://repo.spring.io/snapshot</url>
         <snapshots>
            <enabled>true</enabled>
         </snapshots>
      </repository>
      <repository>
         <id>spring-milestones</id>
         <url>http://repo.spring.io/milestone</url>
         <snapshots>
            <enabled>true</enabled>
         </snapshots>
      </repository>
   </repositories>
   <pluginRepositories>
      <pluginRepository>
         <id>spring-snapshots</id>
         <url>http://repo.spring.io/snapshot</url>
      </pluginRepository>
      <pluginRepository>
         <id>spring-milestones</id>
         <url>http://repo.spring.io/milestone</url>
      </pluginRepository>
   </pluginRepositories>
</project>

2、配置yml文件
（1）application.yml

spring:
  profiles:
    active: dev     #激活application-dev的yml文件，被激活文件的命名方式为application-激活后缀

（2）application-dev.yml

#配置端口
server:
  port: 8079
# Hibernate 相关配置
spring:
  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.OracleDialect  # 方言
        hbm2ddl:
          auto: update                            # 建表方式
  datasource:
    url: jdbc:oracle:thin:@localhost:1521:orcl             # 数据库连接
    username: test            #用户名
    password: a               #密码
    driver-class-name: oracle.jdbc.driver.OracleDriver  # 数据库驱动
#hibernate其他配置
hibernate:
  show_sql: true         # 显示Sql
entitymanager:
  packagesToScan: com.yzh.maven.entity       # 自动扫描的包前缀

3、在com.yzh.maven目录下建立base.entity包和entity包

在base.entity包下建立Entity基础实体类：
package com.yzh.maven.base.entity;
import java.lang.reflect.Field;
import java.util.*;
import java.util.Map.Entry;
public class Entity<T> implements Comparable<T>{
   @Override
    public int compareTo(T t) {
      return 0;
    }

   public List<T> sortList(List<T> list){
      Collections.sort(list,new Comparator<T>(){
         @SuppressWarnings("unchecked")
         @Override
         public int compare(T t1,T t2) {
            return ((Comparable<T>) t1).compareTo(t2);
         }
      });
      return list;
   }

   /**
    * @function name searchList
    * @Description 多条件查询list
    * @param list
    * @param params
    * @return
    * @date 2018-09-03
    * @author yzh
    */ 
   public List<T> searchList(List<T> list,Map<String,Object> params){
      List<T> newList = new ArrayList<T>(); 
       for(T t:list){
          //判断是否一致的标识
          boolean flag = false;
           Iterator<Entry<String, Object>> it = params.entrySet().iterator();
          //遍历map
           while(it.hasNext()){
             String key = it.next().getKey();
             String value = params.get(key)+"";
             if(value.equals(getFiledValue(key,t))){
                flag = true;
             //如果不一致，终止此次循环，确保所有查询条件一致才一致
             }else{
                flag = false;
                break;
             }
          }
           //如果符合查询条件，那么就加入list中
          if(flag){
             if(!newList.contains(t)){
                newList.add(t);
             }
          }
       }
       return newList;
   }

   /**
    * @function name removeOtherListCaseByTheListCaseName
    * @Description 根据list的某个属性名称删除另一个list的某个元素
    * @param
    * @return
    * @date 2018-08-07
    * @author yzh
    * @param <T>
   **/
   public static <T> List<T> removeOtherListCaseByTheListCaseName(List<T> list1,List<T> list2,String fileName) {
      int []arr = new int[list2.size()]; 
      int [] newArr = new int[arr.length];
      //记录重复元素下标
      int b = 0;
      for(int i = 0;i<list1.size();i++){
         for(int m = 0;m<list2.size();m++){
            T t1 = list1.get(i);
            String filedVal1 = getFiledValue(fileName,t1);
            T t2 = list2.get(m);
            //根据fileName属性获取t1的fileName属性值
            String filedVal2 = getFiledValue(fileName,t2);
            try {
               if(filedVal1.equals(filedVal2)){
                  //做删除操作时，遍历的长度一定要是list.size(),因为后面移除对象之后就会导致list长度动态变化，如果使用常量表示，会导致边界异常
                  //记录重复元素的位置
                  arr[b] = i;
                  b++;
               }else{
                  continue;
               }
            } catch (Exception e) {
               e.printStackTrace();
            } 
         }
      }
      //因为要删除list里面的多个的值，所以会涉及到一个问题，就是当你删除掉下标为1的元素时，
      //原来下标为2的元素会自动改变自己的下标为0，后面的元素依次把自己的下标值减1
      //鉴于这种情况，我们想循环删除list中的多个元素的话，就必须从后往前删，这样保障了你删除了一个元素之后，
      //list中元素的下标移动不会影响到那些需要删除，但是还未删除到的元素 
      //1.顺序排序
      Arrays.sort(arr);
      //2.反向数组
      for(int i = 0;i<arr.length;i++){
         newArr[i] = arr[arr.length-i-1];
      }
      //3.删除元素
      for(int i = 0;i<newArr.length;i++){
         list1.remove(newArr[i]);
      }
      return list1;
   }


   /**
    * @function name getFiledValue
    * @Description 获取List对象元素的某个属性的值
    * @param filedName 字段名
    * @param <T>
    * @return
    * @date 2018-08-07
    * @author yzh
    */ 
   public static <T> String getFiledValue(String filedName,T t){
      Field field = null;
      Object fieldVal = null;
      try {
         field = t.getClass().getDeclaredField(filedName);
         //设置私有属性允许访问，否则无法将值set进实体类的私有属性中
         field.setAccessible(true);
         fieldVal = field.get(t);
      } catch (Exception e) {
         e.printStackTrace();
      }
      return fieldVal+"";
   }
   /**
    * @function name removeListCaseByFieldName
    * @Description 根据实体类的某个字段和输入值来删除元素
    * @param filed 字段名
    * @param removeByValue 删除值
    * @param List<T>
    * @return
    * @date 2018-09-03
    * @author yzh
    */ 
   public  List<T> removeListCaseByFieldName(List<T> list,String field,String removeByValue){
      for(int i = 0;i<list.size();i++){
         T t = list.get(i);
         if(getFiledValue(field,t).equals(removeByValue)){
            list.remove(t);
         }
      }
      return list;
   }
}

4、在Entity包下建立UserInfo实体类

package com.yzh.maven.entity;
import com.yzh.maven.base.entity.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
@javax.persistence.Entity
@Table(name="userinfo",schema="TEST")
public class UserInfo extends Entity<UserInfo> implements Serializable{
   private static final long serialVersionUID = 1L;
   @Id
   @GeneratedValue(strategy= GenerationType.AUTO)
   private int userId;
   private String userName;
   private String password;
   private int age;
   private String sex;
   private String tel;
   private String email;
   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 int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public String getSex() {
      return sex;
   }
   public void setSex(String sex) {
      this.sex = sex;
   }
   public String getTel() {
      return tel;
   }
   public void setTel(String tel) {
      this.tel = tel;
   }
   public String getEmail() {
      return email;
   }
   public void setEmail(String email) {
      this.email = email;
   }
   public UserInfo(String userName, String password, int age, String sex,
                    String tel, String email) {
      super();
      this.userName = userName;
      this.password = password;
      this.age = age;
      this.sex = sex;
      this.tel = tel;
      this.email = email;
   }
   public UserInfo() {
      super();
   }

    @Override
    public int compareTo(UserInfo u) {
        if(this == u){
            return 0;            
        }else{   
           if(userName.compareTo(u.getUserName()) > 0){
              return 1;
           }else if(userName.compareTo(u.getUserName()) == 0){
              return 0;
           }else{
              return -1;
           }
        }
   }

   @Override
   public String toString() {
      return "UserInfo [userName=" + userName + ", password=" + password
            + ", age=" + age + ", sex=" + sex + ", tel=" + tel + ", email="
            + email + "]";
   }
}

5、构建UserInfoDao接口

package com.yzh.maven.mapper;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import com.yzh.maven.entity.UserInfo;
/**
 * @author
 */
public interface UserInfoDao extends JpaRepository<UserInfo,Integer>{
    /**
     * 查询所有
     * @return
     */
    @Query("select u from UserInfo u")
    public List<UserInfo> findAll();
}

说明：UserInfoDao接口必须继承JpaRepository接口，这是我们才可以在实现类中使用@Autowired注解获得其实例的持久层方法。

6、测试
通过测试，我们看到，在数据库中我们已经建立了userinfo表