SpringBoot整合SpringBoot-Jpa：一

1. Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。
2. JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。他的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。值得注意的是，JPA是在充分吸收了现有Hibernate，TopLink，JDO等ORM框架的基础上发展而来的，具有易于使用，伸缩性强等优点。从目前的开发社区的反应上看，JPA受到了极大的支持和赞扬，其中就包括了Spring与EJB3.0的开发团队。
3. 注意:JPA是一套规范，不是一套产品，那么像Hibernate,TopLink,JDO他们是一套产品，如果说这些产品实现了这个JPA规范，那么我们就可以叫他们为JPA的实现产品。

一.整合SpringBoot整合springBoot jpa

1. 添加pom文件的内容
2. 配置yml文件

 pom文件核心内容:

      <!--spring-boot的核心启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

      <!--spring boot jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <version>2.0.0.RELEASE</version>
        </dependency>

      <!--数据库连接器-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--开启test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 阿里巴巴druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

yml:核心内容

server:
  port: 8080
spring:
  mvc:
    view:
      prefix: /
      suffix: .html
  servlet:
      multipart:
        max-file-size: 20Mb
        max-request-size: 20Mb

  #数据源配置
  #data:
  resources:
    static-locations: classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/,classpath:/itstyle/, file:/
  datasource:
    url: jdbc:mysql://localhost:3306/test_jpa1?characterEncoding=utf-8
    username: root
    password: 123456

    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    #下面是更加详细的配置，可以不用配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true

    #配置监控控制拦截的fileters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,log4j
    maxPoolPreparedStatementsPerConnectionSize: 20
    useGlobalDataSourceStat: true

  jpa:#jpa核心配置
    hibernate:  #更新或者创建数据表结构
      ddl-auto: update
      naming:
        physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
      #控制台显示sql
    show-sql: true

测试是否整合成功:

一：新建entity包和repository包：

在entity包底下新建User类

package whut.entity;

import org.hibernate.annotations.Proxy;

import javax.persistence.*;


@Entity//注明是一个实体对象
@Table(name = "t_users")//定义表与数据库关联起来，在正向工程里面就是创建一个t_users的表
public class Users {

    @Id//表明为主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//表明主键自增策略
    @Column(name = "id")//对应数据库中的字段
    private Integer id;

    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private Integer age;

    @Column(name = "address")
    private String address;

 

    public Users() {
    }

    public Users(String name, Integer age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public Users(String name, Integer age, String address, Role role) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.role = role;
    }



    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Users{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

 注:GeneratedValue 有4生成策略

• IDENTITY：采用数据库ID自增长的方式来自增主键字段，Oracle 不支持这种方式； 
• AUTO： JPA自动选择合适的策略，是默认选项； 
• SEQUENCE：通过序列产生主键，通过@SequenceGenerator 注解指定序列名，MySql不支持这种方式 
• TABLE：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植。

详情介绍看：待填更新。

二：新建Repository接口

这里先使用JpaRepository接口来测试

package whut.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import whut.entity.Users;

public interface UserRepository extends JpaRepository<Users,Integer> {
}

JpaRepository拥有的方法

三：新建我们的测试代码

在test包底下新建TestUserJpa类

@RunWith(SpringJUnit4ClassRunner.class)//测试的启动器
@SpringBootTest(classes = App.class)//测试的启动器
public class JpaOneToManyTest {


    @Autowired
    private UserRepository userRepository;


    @Test//注明为测试方法
    public void testSave() {
        //创建用户（包含外键）
        Users user = new Users();
        user.setAddress("天津");
        user.setName("张三");
        user.setAge(22);


        //保存
        userRepository.save(user);
    }

   
    @Test
    public void testFind() {
        Users user = this.userRepository.getOne(1);

        System.out.println(user);
  
    }
}

 

控制台输出如下：