Spring boot之JPA

JPA

步骤：

（1）在pom.xml添加mysql,spring-data-jpa依赖

（2）在application.properties文件中配置mysql连接配置文件

（3）在application.properties文件中配置JPA配置信息

（4）编写测试例子

  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.kfit</groupId>
  <artifactId>spring-boot-jpa</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>spring-boot-jpa</name>
  <url>http://maven.apache.org</url>
  

    <!-- 
spring boot 父节点依赖,引入这个之后相关的引入就不需要添加version配置，spring boot会自动选择最合适的版本进行添加。
 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.1.RELEASE</version>
    </parent>
    
    
      
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 指定一下jdk的版本 ，这里我们使用jdk 1.8 ,默认是1.6 -->
    <java.version>1.8</java.version>
  </properties>

  <dependencies>
          
          <!-- 
              spring-boot-starter-web: MVC,AOP的依赖包....
           -->
          <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <!-- 
                    <version></version>
                    由于我们在上面指定了 parent(spring boot)
                 -->
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        
        
        <!-- 添加fastjson 依赖包. -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.15</version>
        </dependency>
        
        <!-- spring boot devtools 依赖包. -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
           <scope>true</scope>
        </dependency>
        
        <!-- 添加MySQL数据库驱动依赖包. -->
        <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
        </dependency>
        
        <!-- 添加Spring-data-jpa依赖. -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
  </dependencies>

    <!-- 构建节点. -->
    <build>
        <plugins>
            <!-- 这是spring boot devtool plugin -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                      <!--fork :  如果没有该项配置，肯呢个devtools不会起作用，即应用不会restart -->
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>    

</project>

配置文件

########################################################
###datasource -- u6307u5b9amysqlu6570u636eu5e93u8fdeu63a5u4fe1u606f.
########################################################
spring.datasource.url = jdbc:mysql://localhost:3306/cyj
spring.datasource.username = root
spring.datasource.password = 123456
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10


########################################################
### Java Persistence Api --  Spring jpa
########################################################
# Specify the DBMS
spring.jpa.database = MYSQL
# Show or not log for each sql query
spring.jpa.show-sql = true
# Hibernate ddl auto (create, create-drop, update)
spring.jpa.hibernate.ddl-auto = update
# Naming strategy
#[org.hibernate.cfg.ImprovedNamingStrategy  #org.hibernate.cfg.DefaultNamingStrategy]
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy
# stripped before adding them to the entity manager)
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

(1) 创建实体类Cat 。

(2) 创建jpa repository类操作持久化(CrudRepository)。

(3) 创建service类。

(4) 创建restful请求类。

(5) 测试;

package com.kfit.demo.bean;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
 * 创建了一个实体类。
 * 
 * 如何持久化呢？
 * 
 * 1、使用@Entity进行实体类的持久化操作，当JPA检测到我们的实体类当中有
 * 
 * @Entity 注解的时候，会在数据库中生成对应的表结构信息。
 * 
 * 
 * 如何指定主键以及主键的生成策略？
 * 
 * 2、使用@Id指定主键.
 * 
 * 
 * 
 * @author Angel -- 守护天使
 * @version v.0.1
 * @date 2016年12月17日
 */
@Entity
public class Cat {
    
    /**
     * 使用@Id指定主键.
     * 
     * 使用代码@GeneratedValue(strategy=GenerationType.AUTO)
     * 指定主键的生成策略，mysql默认的是自增长。
     * 
     */
    @Id @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;//主键.
    
    private String catName;//姓名. cat_name
    
    private int catAge;//年龄. cat_age;

    public int getId() {
        return id;
    }

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

    public String getCatName() {
        return catName;
    }

    public void setCatName(String catName) {
        this.catName = catName;
    }

    public int getCatAge() {
        return catAge;
    }

    public void setCatAge(int catAge) {
        this.catAge = catAge;
    }
    
    
}

package com.kfit.demo.repository;

import org.springframework.data.repository.CrudRepository;

import com.kfit.demo.bean.Cat;

public interface CatRepository extends CrudRepository<Cat, Integer>{

}

package com.kfit.demo.service;

import javax.annotation.Resource;
import javax.transaction.Transactional;

import org.springframework.stereotype.Service;

import com.kfit.demo.bean.Cat;
import com.kfit.demo.repository.CatRepository;

@Service
public class CatService {
    
    @Resource
    private CatRepository catRepository;
    
    /**
     * save,update ,delete 方法需要绑定事务.
     * 
     * 使用@Transactional进行事务的绑定.
     * 
     * @param cat
     */
    
    //保存数据.
    @Transactional
    public void save(Cat cat){
        catRepository.save(cat);
    }
    
    //删除数据》
    @Transactional
    public void delete(int id){
        catRepository.delete(id);
    }
    
    //查询数据.
    public Iterable<Cat> getAll(){
        return catRepository.findAll();
    }
    
}

package com.kfit.demo.controller;

import javax.annotation.Resource;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.kfit.demo.bean.Cat;
import com.kfit.demo.service.CatService;

@RestController
@RequestMapping("/cat")
public class CatController {
    
    @Resource
    private CatService catService;
    
    @RequestMapping("/save")
    public String save(){
        Cat cat = new Cat();
        cat.setCatName("jack");
        cat.setCatAge(3);
        catService.save(cat);
        return "save ok.";
    }
    
    @RequestMapping("/delete")
    public String delete(){
        catService.delete(1);
        return "delete ok";
    }
    
    @RequestMapping("/getAll")
    public Iterable<Cat> getAll(){
        return catService.getAll();
    }
    
}

Spring Boot JPA 总结
---------------------
1、需要添加相应的依赖包;
2、需要在application.properties文件添加配置信息；
3、需要创建一个实体类,比如Cat;
4、需要创建一个接口继承CrudRepository;
5、需要创建一个Service;
6、需要创建一个Controller;
7、代码测试；

Spring Boot Spring Data JPA介绍

Spring Data 的一个核心接口为我们提供了常用的接口

Repository接口

Repository 接口是 Spring Data 的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法 ：

public interface Repository<T, ID extends Serializable> { }

有这么几点需要强调下：

1. Repository是一个空接口，即是一个标记接口；

2. 若我们定义的接口继承了Repository，则该接口会被IOC容器识别为一个Repository Bean纳入到IOC容器中，进而可以在该接口中定义满足一定规范的方法。

3. 实际上也可以通过@RepositoryDefinition,注解来替代继承Repository接口。

4. 查询方法以find | read | get开头；

5. 涉及查询条件时，条件的属性用条件关键字连接，要注意的是条件属性以首字母大写。

6.使用@Query注解可以自定义JPQL语句实现更灵活的查询。

CrudRepository 接口提供了最基本的对实体类的添删改查操作

  --T save(T entity);//保存单个实体 

  --Iterable<T> save(Iterable<? extends T> entities);//保存集合       

  --T findOne(ID id);//根据id查找实体        

  --boolean exists(ID id);//根据id判断实体是否存在   

  --Iterable<T> findAll();//查询所有实体,不用或慎用!        

  --long count();//查询实体数量          

  --void delete(ID id);//根据Id删除实体        

  --void delete(T entity);//删除一个实体   

  --void delete(Iterable<? extends T> entities);//删除一个实体的集合   

  --void deleteAll();//删除所有实体,不用或慎用!   

PagingAndSortingRepository接口

该接口提供了分页与排序功能

   --Iterable<T> findAll(Sort sort); //排序

   --Page<T> findAll(Pageable pageable); //分页查询（含排序功能）

其它接口

JpaRepository：查找所有实体，排序、查找所有实体，执行缓存与数据库同步

JpaSpecificationExecutor：不属于Repository体系，实现一组 JPA Criteria 查询相关的方法，封装 JPA Criteria 查询条件。通常使用匿名内部类的方式来创建该接口的对象。

自定义 Repository：可以自己定义一个MyRepository接口。

package com.kfit.demo1.repository;

 

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.Param;

import com.kfit.demo1.bean.Cat;

public interface Cat2Repository extends PagingAndSortingRepository<Cat, Integer>{
    
    
    /**
     * 1/ 查询方法 以 get | find | read 开头.
     * 2/ 涉及查询条件时，条件的属性用条件关键字连接，要注意的是条件属性以首字母大写。
     */
    
    //根据catName进行查询 : 根据catName进行查询.
    public Cat findByCatName(String catName);
    
    /**
     * 如何编写JPQL语句， 
     * Hibernate  -- HQL语句.
     * JPQL 语句 和HQL语句是类似的.
     */
    @Query("from Cat where catName=:cn")
    public Cat findMyCatName(@Param("cn")String catName);
}

package com.kfit.demo1.controller;

 

import javax.annotation.Resource;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.kfit.demo1.bean.Cat;
import com.kfit.demo1.service.CatService;

 

@RestController
@RequestMapping("/cat")
public class CatController {
    
    @Resource
    private CatService catService;
    
    @RequestMapping("/save")
    public String save(){
        Cat cat = new Cat();
        cat.setCatName("jack");
        cat.setCatAge(3);
        catService.save(cat);
        return "save ok.";
    }
    
    @RequestMapping("/delete")
    public String delete(){
        catService.delete(1);
        return "delete ok";
    }
    
    @RequestMapping("/getAll")
    public Iterable<Cat> getAll(){
        return catService.getAll();
    }
    
    @RequestMapping("/findByCatName")
    public Cat findByCatName(String catName){
     
        return catService.findByCatName(catName);
    }
    
    @RequestMapping("/findByCatName2")
    public Cat findByCatName2(String catName){
        System.out.println("CatController.findByCatName2()");
        return catService.findByCatName2(catName);
    
    }
    
    @RequestMapping("/selectByCatName")
    public Cat selectByCatName(String catName){
        return catService.selectByCatName(catName);
    }
}