Idea创建spring boot 项目(4)整合Spring Data Jpa

接博客---> Idea创建spring boot 项目(3)集成Lombok

使用工具：

    IDE：idea 2017.2.6

    Spirng boot：1.5.9

    Swagger版本：2.7.0

    Lombok版本：1.16.20

        MySql版本：6.0.6

        数据库连接池：HikariCP 2.7.7

1、添加依赖：

    打开项目build.gradle文件，添加依赖如下：

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'//spring boot 版本
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}


//添加资源库
repositories {
   maven { url 'http://maven.aliyun.com/nexus/content/repositories/central' }//添加阿里仓库
   mavenCentral()//添加Maven中央资源库
}


apply plugin: 'java'// 指定项目为java项目，项目编译(在项目提示符下执行：gradle build)时生成项目的jar包。
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'spring-boot'
apply plugin: 'application'

group = 'com.demo'
version = '1.5.9-SNAPSHOT'
sourceCompatibility = 1.8
targetCompatibility = 1.8

mainClassName = 'com.tinckay.App'//告诉gradle启动类的路径

dependencies {

   compile("org.springframework.boot:spring-boot-starter-web")

   testCompile("org.springframework.boot:spring-boot-starter-test")

   compile("org.springframework.boot:spring-boot-starter-tomcat")

   compile("io.springfox:springfox-swagger2:2.7.0")//swagger2核心依赖
   compile("io.springfox:springfox-swagger-ui:2.7.0")//为项目提供api展示及测试的界面

   compile("org.projectlombok:lombok:1.16.20")//lombok依赖包

   compile("org.springframework.boot:spring-boot-starter-data-jpa")

   compile("mysql:mysql-connector-java:6.0.6")//连接mysql数据库驱动
   compile("com.zaxxer:HikariCP:2.7.7")//HikariCP 数据库连接池依赖

}

2、配置文件：

            打开项目application.properties文件，配置如下信息：

            注意：数据源的配置信息要配本机的；

#配置端口号
server.port=5252

#配置数据源
db.driver=com.mysql.jdbc.Driver
db.username=test
db.password=
db.url=jdbc:mysql://127.0.0.1:3306/demo

#Hibernate Configuration
hibernate.naming.strategy=org.hibernate.cfg.DefaultComponentSafeNamingStrategy
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.hbm2ddl.auto=none
hibernate.connection.autocommit=false
hibernate.ejb.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy
hibernate.show_sql=false
hibernate.format_sql=false

3、编码Jpa配置类：

        在项目com.demo包下创建一个“config”包，在“config”包下创建一个JpaConfig类，作为Jpa的连接类，编写如下代码：

            注意一：在编码期间，要在com.demo包下创建"jpa"包；

            注意二：图下代码，标红两处idea提示有问题，不用理会

package com.demo.config;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.Properties;

/**
 * @author SAM
 * @create 2018-03-15 上午10:02
 * Jpa连接类
 **/
@Configuration
@EnableJpaRepositories(basePackages = {"com.demo.jpa"})
@EnableTransactionManagement
public class JpaConfig {

    @Bean(destroyMethod = "close")//destroyMethod = "close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用. 
    DataSource dataSource(Environment env) {
        HikariConfig dataSourceConfig = new HikariConfig();
        dataSourceConfig.setDriverClassName(env.getRequiredProperty("db.driver"));
        dataSourceConfig.setJdbcUrl(env.getRequiredProperty("db.url"));
        dataSourceConfig.setUsername(env.getRequiredProperty("db.username"));
        dataSourceConfig.setPassword(env.getRequiredProperty("db.password"));
        dataSourceConfig.setMaximumPoolSize(30);

        return new HikariDataSource(dataSourceConfig);
    }

    @Bean
    LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource, Environment env) {
        LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
        entityManagerFactoryBean.setDataSource(dataSource);
        entityManagerFactoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
        entityManagerFactoryBean.setPackagesToScan("com.demo.domain");
        Properties jpaProperties = new Properties();

        //Configures the used database dialect. This allows Hibernate to create SQL
        //that is optimized for the used database.
        jpaProperties.put("hibernate.dialect", env.getRequiredProperty("hibernate.dialect"));

        //Specifies the action that is invoked to the database when the Hibernate
        //SessionFactory is created or closed.
        jpaProperties.put("hibernate.hbm2ddl.auto", env.getRequiredProperty("hibernate.hbm2ddl.auto"));

        //Configures the naming strategy that is used when Hibernate creates
        //new database objects and schema elements
        jpaProperties.put("hibernate.ejb.naming_strategy", env.getRequiredProperty("hibernate.ejb.naming_strategy"));

        //If the value of this property is true, Hibernate writes all SQL
        //statements to the console.
        jpaProperties.put("hibernate.show_sql", env.getRequiredProperty("hibernate.show_sql"));

        //If the value of this property is true, Hibernate will format the SQL
        //that is written to the console.
        jpaProperties.put("hibernate.format_sql", env.getRequiredProperty("hibernate.format_sql"));

        entityManagerFactoryBean.setJpaProperties(jpaProperties);
        return entityManagerFactoryBean;
    }

    @Bean
    JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory);
        return transactionManager;
    }
}



/**
 @EnableJpaRepositories 注解用于Srping JPA的代码配置，用于取代xml形式的配置文件;
            basePackage 用于配置扫描Repositories所在的package及子package。

 @EnableTransactionManagement 开启注解事务管理，等同于xml配置文件中的 
             Spring Boot 使用事务非常简单，首先使用注解 @EnableTransactionManagement 开启事务支持后，
             然后在访问数据库的Service方法上添加注解 @Transactional 便可。
             如果@Transactional注解在类上，则整个类的所有方法都默认支持事务。
 **/

4、建表：

        在连接的数据库建立一张“demo”表，mysql语句如下：

CREATE TABLE demo(
   id INT NOT NULL AUTO_INCREMENT,
   name VARCHAR(50) NOT NULL,
   create_time DATE,
   PRIMARY KEY (id )   );

5、创建映射实体类：

        在项目com.demo.domain包下创建一个“Demo”实体类，如下：

package com.demo.domain;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import javax.persistence.*;
import java.util.Date;

/**
 * @author SAM
 * @create 2018-03-16 上午9:15
 **/
@Entity
@Table(name = "demo")
@Data
public class Demo {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "name", nullable = false, length = 50)
    private String name;

    @Temporal(TemporalType.TIMESTAMP)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
    @Column(name = "create_time", nullable = false)
    private Date createTime;
}
    /**
     * JPA的注解来定义实体的时候，使用@Id来注解主键属性即可。如果数据库主键是自增长的，需要在增加一个注解@GeneratedValue
     *    @GeneratedValue 注解的strategy属性提供四种值：
            –AUTO： 主键由程序控制，是默认选项，不设置即此项。
            –IDENTITY：主键由数据库自动生成，即采用数据库ID自增长的方式，Oracle不支持这种方式。
            –SEQUENCE：通过数据库的序列产生主键，通过@SequenceGenerator 注解指定序列名，mysql不支持这种方式。
            –TABLE：通过特定的数据库表产生主键，使用该策略可以使应用更易于数据库移植。

        如果某个实体类的字段包含 Date类型，那么数据库中应该存储的是 “yyyy-MM-dd hh:MM:ss”的形式，针对这种形式的存储，@Temporal 有三种注解值对应。
            第一种：@Temporal(TemporalType.DATE)--->实体类会封装成日期“yyyy-MM-dd”的 Date类型。
            第二种：@Temporal(TemporalType.TIME)--->实体类会封装成时间“hh-MM-ss”的 Date类型。
            第三种：@Temporal(TemporalType.TIMESTAMP)--->实体类会封装成完整的时间“yyyy-MM-dd hh:MM:ss”的 Date类型。

         @JsonFormat
         此注解用于属性或者方法上（最好是属性上），可以方便的把Date类型直接转化为我们想要的模式，
            @JsonFormat 默认情况下timeZone为GMT（即标准时区），所以会造成输出少8小时。
            @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
                 作用：1）入参时，请求报文只需要传入yyyy-MM-dd HH-mm-ss字符串进来，则自动转换为Date类型数据。
                      2）出参时，Date类型的数据自动转换为yyyy-MM-dd HH-mm-ss字符串返回出去。
     */

6、创建访问数据库的Jpa接口:

        在项目com.demo.jpa包下创建“DemoJpa”接口，代码如下：

package com.demo.jpa;

import com.demo.domain.Demo;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * @author SAM
 * @create 2018-03-16 上午9:47
 **/

public interface DemoJpa extends JpaRepository,Integer> {
}

备注：有关spring data jpa简介的链接地址：Spring Data Jpa 简介

7、编写Jpa案例：

    在项目com.demo.controller.DemoController类中编写如下案例：

@Autowired DemoJpa demoJpa;

@ApiOperation(value = "Spring Data Jpa示例方法",notes = "Idea创建spring boot 项目(4)整合Spring Data Jpa")
@ApiImplicitParam(name = "name",value = "名字",required = true,paramType = "query",dataType = "String",defaultValue = "demo")
@RequestMapping(value = "/jpaDemo", method = RequestMethod.POST)
public ResponseMsg jpaDemo(@RequestParam String name) {
    Demo demo = new Demo();
    demo.setName(name);
    demo.setCreateTime(new Date());

    try {
        Demo save = demoJpa.save(demo);
        return new ResponseMsg(1, "save success", save);
    } catch (Exception e) {
        e.printStackTrace();
        return new ResponseMsg(0, "save fail", null);
    }
}

8、至此，编码阶段完成，项目结构如下图:

9、启动：

        运行启动类App（快捷键“Shift + F10”）；

        访问swagger页面：http://localhost:5252/swagger-ui.html#/   如下图：

10、测试接口：

        测试DemoController.jpaDemo()方法，如下图：

至此，spring boot整合Spring Data Jpa项目演示完毕，如有疑问请在评论回复探讨，希望这篇博客对你有用，谢谢；