Spring Boot之使用JPA访问数据

这篇文章简单讲解使用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接口去获取它。

原文连接：https://spring.io/guides/gs/accessing-data-jpa/