这篇文章简单讲解使用Spring Data JPA在关系型数据库中存储和取出数据。
你将创建什么样的应用
你将创建一个在内存数据库中存取CustomerPOJOs的应用。
准备工作：
- 大约15分钟
- 你喜欢的文本编辑器或者IDE
- JDK >= 1.8
- Maven >= 3.0
创建目录结构
在你选择的工程目录下，创建如下目录结构；例如在*nix系统使用mkdir -p src/main/java/hello:
└── src
└── main
└── java
└── hello
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>org.springframework</groupId>
<artifactId>gs-accessing-data-jpa</artifactId>
<version>0.1.0</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.2.RELEASE</version>
</parent>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-releases</id>
<name>Spring Releases</name>
<url>https://repo.spring.io/libs-release</url>
</repository>
<repository>
<id>org.jboss.repository.releases</id>
<name>JBoss Maven Release Repository</name>
<url>https://repository.jboss.org/nexus/content/repositories/releases</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-releases</id>
<name>Spring Releases</name>
<url>https://repo.spring.io/libs-release</url>
</pluginRepository>
</pluginRepositories>
</project>
定义一个简单的实体
在这个例子中，通过JPA实体的注解，新建一个Customer的对象。
src/main/java/hello/Customer.java
package hello;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Customer {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private Long id;
private String firstName;
private String lastName;
protected Customer() {}
public Customer(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
@Override
public String toString() {
return String.format(
"Customer[id=%d, firstName='%s', lastName='%s']",
id, firstName, lastName);
}
}
Customer 类有三个属性, id, firstName,和 lastName. 类有两个构造函数.JPA需要一个 默认的构造函数 . 你不需要直接使用它，所以设置成 protected. 另一个构造函数只是为了方便创建 Customer 实例保存在数据库中.
在这篇文章中为了简洁，省略了getters和setters方法。
Customer 类用@Entity注释，表明它是一个JPA实体。因为没有@Table注释，数据库中映射的表名为实体名Customer.
@Entity注释类时，数据库映射后表名为实体名，字段名和属性名称也相同
@Table注释类时，默认是和@Entity相同，但是可以用@Table(name='value')指定表名，用@Column(name='value')指定字段名。
Customer 的id 属性用@Id注释JPA将识别它，并把它作为对象的ID.id属性还被@GeneratedValue 注解，表明ID将自动的增加。
firstName 和lastName属性没有被注释.他们将被映射成和属性名相同的字段。
toString() 可以很方便的输出customer的属性
创建简单的查询
Spring Data JPA 只要是使用 JPA 在关系型数据库中存储数据. 它最大的特点就是，继承repository接口，在运行期间可以自动的帮你去创建查询方法.
创建Customer的repository接口：
src/main/java/hello/CustomerRepository.java
package hello;
import java.util.List;
import org.springframework.data.repository.CrudRepository;
public interface CustomerRepository extends CrudRepository<Customer, Long> {
List<Customer> findByLastName(String lastName);
}
CustomerRepository 继承CrudRepository接口.CrudRepository 有两个规定的参数实体类型和ID类型，我们这里传Customer和Long.CustomerRepository通过对CrudRepository继承有了对Customer持久化的几个方法，包含基本的增删改查。
Spring Data JPA同样允许你自己定义一些其他的查询方法，只需要通过一些简单的命名规则.在CustomerRepository中findByLastName()就是这样的方法.
在一般的Java应用中，你会去写一个类去实现CustomerRepository.但是Spring Data JPA是如此的强大：你不需要去写repository接口的实现。Spring Data JPA会在应用运行过程中帮你自动的创建。
创建应用程序
src/main/java/hello/Application.java
package hello;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class Application {
private static final Logger log = LoggerFactory.getLogger(Application.class);
public static void main(String[] args) {
SpringApplication.run(Application.class);
}
@Bean
public CommandLineRunner demo(CustomerRepository repository) {
return (args) -> {
// save a couple of customers
repository.save(new Customer("Jack", "Bauer"));
repository.save(new Customer("Chloe", "O'Brian"));
repository.save(new Customer("Kim", "Bauer"));
repository.save(new Customer("David", "Palmer"));
repository.save(new Customer("Michelle", "Dessler"));
// fetch all customers
log.info("Customers found with findAll():");
log.info("-------------------------------");
for (Customer customer : repository.findAll()) {
log.info(customer.toString());
}
log.info("");
// fetch an individual customer by ID
Customer customer = repository.findOne(1L);
log.info("Customer found with findOne(1L):");
log.info("--------------------------------");
log.info(customer.toString());
log.info("");
// fetch customers by last name
log.info("Customer found with findByLastName('Bauer'):");
log.info("--------------------------------------------");
for (Customer bauer : repository.findByLastName("Bauer")) {
log.info(bauer.toString());
}
log.info("");
};
}
}
@SpringBootApplication 是个“复合”注解，它包含以下注解作用：
@Configuration注解将类作为程序上下文bean的源.@EnableAutoConfiguration告诉Spring Boot启动时添加beans和其他大量的设置.- 本来你需要增加
@EnableWebMvc为一个 Spring MVC 应用, 但是Spring Boot会自动增加. 这个注释表明这个应用是一个web应用并且去激活像DispatcherServlet这些设置. @ComponentScan告诉Spring 去查找其他的组件，配置和services 在hello包中,并且允许发现controllers.
main()方法中使用Spring Boot’s SpringApplication.run()方法去启动应用. 不知道你有没注意到我们没有一个 XML文件? 甚至连 web.xml 文件也没有. 这个web应用是100% 纯Java并且你不要处理任何基础的配置.
main() 方法里有几个CustomerRepository 的测试. 首先,从Spirng应用上下文中获取CustomerRepository . 然后使用save() 方法保存几个 Customer 对象. 接着, 使用 findAll()方法从数据库获取所有 Customer对象. 同样可以使用 findOne() 通过id获取一个 Customer对象. 最后, 也可以用findByLastName() 方法通过 "Bauer"去查找 Customer对象.
默认的Spring Boot的JPA repository支持在
@SpringBootApplication所在包及其子包中扫描查找。如果你定义JPA repository接口的位置不明显，你可以使用@EnableJpaRepositories注解并传basePackageClasses=MyRepository.class参数来指出所在位置。
编译成JAR文件
你可以把应用编译成包含必须依赖，类和资源的JAR文件。JAR文件更方便在不同的运行环境中部署。
你可以运行应用使用./mvnw spring-boot:run命令.或者用./mvnw clean package命令编译成JAR文件.然后那你就可以运行JAR文件：
java -jar target/gs-accessing-data-jpa-0.1.0.jar
这个命令将创建一个可运行的JAR文件，当然你也可以编译成WAR文件。
你将会看见如下一些内容：
== Customers found with findAll():
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=2, firstName='Chloe', lastName='O'Brian']
Customer[id=3, firstName='Kim', lastName='Bauer']
Customer[id=4, firstName='David', lastName='Palmer']
Customer[id=5, firstName='Michelle', lastName='Dessler']
== Customer found with findOne(1L):
Customer[id=1, firstName='Jack', lastName='Bauer']
== Customer found with findByLastName('Bauer'):
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=3, firstName='Kim', lastName='Bauer']
总结
恭喜你！你已经学会了一个简单使用Spring Data JPA去存储一个对象进数据库中，并且通过repository接口去获取它。
