YueXian

YueXian的博客

0%

SpringBoot-整合JPA

发表于 更新于 分类于
本文字数： 5.8k 阅读时长 ≈ 11 分钟

前言

JPA (Java Persistence API) 是 Sun 官方提出的 Java 持久化规范。它为 Java 开发人员提供了一种对象/关联映射工具来管理 Java 应用中的关系数据。Spring Boot Jpa 是 Spring 基于 ORM 框架、Jpa 规范的基础上封装的一套 Jpa 应用框架，可使开发者用极简的代码即可实现对数据的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！

pom.xml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
<?xml version="1.0" encoding="UTF-8"?>
<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>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.huzh</groupId>
    <artifactId>springboot-jpa</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>springboot-jpa</name>
    <description>springboot-jpa</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </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>
</project>

配置jpa和数据库

使用xxx.yml配置（使用xxx.properties也可以）。此处配置可能会导致数据库事务无法使用，如需使用事务请参考SpringBoot 使用事务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
spring:
  #数据库配置
  datasource:
    url: jdbc:mysql://localhost:3306/test?serverTimezone=GMT
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

  ##validate  加载hibernate时，验证创建数据库表结构
  ##create   每次加载hibernate，重新创建数据库表结构，这就是导致数据库表数据丢失的原因。
  ##create-drop        加载hibernate时创建，退出是删除表结构
  ##update                 加载hibernate自动更新数据库结构
  ##validate 启动时验证表的结构，不会创建表
  ##none  启动时不做任何操作
  #jpa配置
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

#端口号
server:
  port: 8080

创建实体类City

JPA可以自动生成表。

  1. @Entity注解：
    • @Entity必须与@Id注解结合使用，否则No identifier specified for entity:
    • 其name 属性：
      (可选)实体名称。 缺省为实体类的非限定名称。
      该名称用于引用查询中的实体。
      该名称不能是Java持久性查询语言中的保留字面值。
    • 不与@Table结合的话表名默认为SnakeCaseStrategy(命名策略 )为表名
      若使用name属性且没有与@Table结合，则表名为 name值的SnakeCaseStrategy(命名策略 )
  2. 其中@Table常用的两个属性：
    • name 用来命名 当前实体类 对应的数据库 表的名字
    • uniqueConstraints 用来批量命名唯一键
      其作用等同于多个：@Column(unique = true)
  3. 主键采用uuid生成策略。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    @Entity
    @Table(name = "city")
    public class City {

        @Id
        @GeneratedValue(generator = "system-uuid")
        @GenericGenerator(name = "system-uuid", strategy = "uuid")
        private String cityId;
        private String cityName;
        private String cityIntroduce;

        public City(String cityId, String cityName, String cityIntroduce) {
            this.cityId = cityId;
            this.cityName = cityName;
            this.cityIntroduce = cityIntroduce;
        }

        public City(String cityName, String cityIntroduce) {
            this.cityName = cityName;
            this.cityIntroduce = cityIntroduce;
        }

        public City() {
        }

        public String getCityId() {
            return cityId;
        }

        public void setCityId(String cityId) {
            this.cityId = cityId;
        }

        public String getCityName() {
            return cityName;
        }

        public void setCityName(String cityName) {
            this.cityName = cityName;
        }

        public String getCityIntroduce() {
            return cityIntroduce;
        }

        public void setCityIntroduce(String cityIntroduce) {
            this.cityIntroduce = cityIntroduce;
        }
    }

    创建DAO

    jpa提供基本查询和复杂的查询
    基本查询也分为两种，一种是 Spring Data 默认已经实现，一种是根据查询的方法来自动解析成 SQL。这里用到了自定义的简单查询。复杂查询有时间在总结。
    1
    2
    3
    4
    5
    6
    public interface CityRepository extends JpaRepository<City, String> {

        void deleteByCityId(String id);

        City findByCityId(String id);
    }

    创建controller

  4. @Autowired自动装配，其作用是为了消除代码Java代码里面的getter/setter与bean属性中的property。可以用@Resource代替。
  5. @GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。该注解将HTTP Get 映射到 特定的处理方法上。
  6. 删除方法需加@Transactional，否则报错
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    @RestController
    public class CityController {
        
        @Autowired
        private CityRepository cityRepository;

        //http://localhost:8080/saveCity?cityName=北京&cityIntroduce=中国首都
        @GetMapping(value = "saveCity")
        public String saveCity(String cityName, String cityIntroduce) {
            City city = new City(cityName, cityIntroduce);
            cityRepository.save(city);
            return "success";
        }

        //http://localhost:8080/deleteCity?cityId=2
        @GetMapping(value = "deleteCity")
        @Transactional
        public String deleteCity(String cityId) {
            cityRepository.deleteByCityId(cityId);
            return "success";
        }

        //http://localhost:8080/updateCity?cityId=3&cityName=郑州&cityIntroduce=河南省省会
        @GetMapping(value = "updateCity")
        public String updateCity(String cityId, String cityName, String cityIntroduce) {
            City city = new City(cityId, cityName, cityIntroduce);
            cityRepository.save(city);
            return "success";
        }

        //http://localhost:8080/getCityById?cityId=3
        @GetMapping(value = "getCityById")
        public City getCityById(String cityId) {
            City city = cityRepository.findByCityId(cityId);
            return city;
        }
    }

    测试检验

    略….

欢迎关注我的其它发布渠道