标签分类
技术文章
当前位置:主页 > 计算机编程 > java > SpringBoot系列教程JPA如何环境搭建

SpringBoot系列教程JPA基础环境搭建的步骤

  • 发布时间:
  • 作者:码农之家原创
  • 点击:107

SpringBoot系列教程JPA如何环境搭建

这篇文章主要知识点是关于SpringBoot,JPA,环境搭建,SpringBoot系列教程JPA如何环境搭建,SpringBoot集成JPA的示例代码 的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下电子书

Spring Boot+Vue全栈开发实战
  • 类型:Spring大小:196.3 MB格式:PDF出版:清华大学出版社作者:王松
立即下载

JPA(Java Persistence API)Java持久化API,是 Java 持久化的标准规范,Hibernate是持久化规范的技术实现,而Spring Data JPA是在 Hibernate 基础上封装的一款框架。JPA作为标准,实际上并没有说局限于某个固定的数据源,事实上mysql,mongo, solr都是ok的。接下来我们将介绍下springboot结合jpa 来实现mysql的curd以及更加复杂一点的sql支持

jpa系列教程将包含以下几块

  • 环境搭建
  • 基础的插入、修改、删除数据的使用姿势
  • 基础的单表查询,如(>, <, = , in, like, between),分页,排序等
  • 多表关联查询
  • 事物使用

本篇为开始第一篇,先搭建一个可以愉快玩耍的jpa项目

I. 环境搭建

我们选择的数据库为mysql,所以有必要先安装一下,这里跳过mysql的安装教程,直接进入springboot项目的搭建

1. pom依赖

我们这里选择的是2.0.4.RELEASE版本进行演示

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

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
  <java.version>1.8</java.version>
</properties>

<dependencies>
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.45</version>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>

  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
  </dependency>
  
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
  </dependency>
</dependencies>

<build>
  <pluginManagement>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </pluginManagement>
</build>

<repositories>
  <repository>
    <id>spring-milestones</id>
    <name>Spring Milestones</name>
    <url>https://repo.spring.io/milestone</url>
    <snapshots>
      <enabled>false</enabled>
    </snapshots>
  </repository>
</repositories>

上面的pom依赖中,关键的是下面两个, 第一个引入的是jpa相关包,后面那个则是mysql的连接依赖,相当于指定操作mysql数据库

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>

2. 数据准备

创建一个测试表进行后续的读写操作,为了后续的事物讲解方便,我们创建一个表,里面存了每个人的钱

CREATE TABLE `money` (
 `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
 `name` varchar(20) NOT NULL DEFAULT '' COMMENT '用户名',
 `money` int(26) NOT NULL DEFAULT '0' COMMENT '钱',
 `is_deleted` tinyint(1) NOT NULL DEFAULT '0',
 `create_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
 `update_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
 PRIMARY KEY (`id`),
 KEY `name` (`name`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

在表中随意插入几条数据,以方便后面使用

INSERT INTO `money` (`id`, `name`, `money`, `is_deleted`, `create_at`, `update_at`)
VALUES
  (1, '一灰灰blog', 100, 0, '2019-04-18 17:01:40', '2019-04-18 17:01:40'),
  (2, '一灰灰2', 200, 0, '2019-04-18 17:01:40', '2019-04-18 17:01:40');

SpringBoot系列教程JPA之基础环境搭建的方法

3. 属性配置

创建springboot工程之后,添加mysql的相关配置,在resources目录下,新建文件 application.properties

## DataSource
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/story?useUnicode=true&characterEncoding=UTF-8&useSSL=false
#spring.datasource.driver-class-name= com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=

SpringBoot系列教程JPA之基础环境搭建的方法

4. 项目构建并测试

根据JPA的一般使用姿势,我们需要针对上面的表,创建一个对应的POJO对象,将它们关联起来,代码如下:

  • 注意下几个注解 @Entity, @Table, @Column, @Id, @GeneratedValue
  • 注意下POJO中字段的类型,这里保证了和db的字段定义类型一致
  • (关于上面两点的更多知识点,后面的文章会给出更详细用法说明,欢迎持续跟进)
package com.git.hui.boot.jpa.entity;

import lombok.Data;

import javax.persistence.*;
import java.sql.Date;

/**
 * Created by @author yihui in 21:01 19/6/10.
 */
@Data
@Entity
@Table(name = "money")
public class MoneyPO {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Integer id;

  @Column(name = "name")
  private String name;

  @Column(name = "money")
  private Long money;

  @Column(name = "is_deleted")
  private Byte isDeleted;

  @Column(name = "create_at")
  private Date createAt;

  @Column(name = "update_at")
  private Date updateAt;
}

表结构定义完毕之后,接下来就是定义db的操作api,jpa的使用,通过方法名来解析出对应的sql,我们这里定义一个简单的Money表的操作API:

  • MoneyDemoRepository 继承自 JpaRepository
  • 两个泛型参数,第一个表示这个repository操作的表绑定的POJO,第二个表示自增id类型
package com.git.hui.boot.jpa.repository;

import com.git.hui.boot.jpa.entity.MoneyPO;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * Created by @author yihui in 21:01 19/6/10.
 */
public interface MoneyDemoRepository extends JpaRepository<MoneyPO, Integer> {
}

上面两个定义完毕之后,不需要其他的操作,就可以进行测试环境了,上面这个Repository提供了一些简单的操作

package com.git.hui.boot.jpa;

import com.git.hui.boot.jpa.demo.JpaQueryDemo;
import com.git.hui.boot.jpa.entity.MoneyPO;
import com.git.hui.boot.jpa.repository.MoneyDemoRepository;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Created by @author yihui in 20:58 19/6/10.
 */
@SpringBootApplication
public class Application {
  public Application(MoneyDemoRepository moneyDemoRepository) {
    MoneyPO moneyPO = moneyDemoRepository.findById(1).get();
    System.out.println(moneyPO);
  }

  public static void main(String[] args) {
    SpringApplication.run(Application.class);
  }
}

针对上面的测试case进行简单的说明,前面定义了一个POJO对象和一个RepositoryAPI,我们想直接操作对应的表,需要借助这个RepositoryAPI对象,但是它是接口类型,我们没法直接使用的,因为我们是在Spring生态体系中,所以可以直接通过IoC注入方式使用

所以上面的测试中,MoneyDemoRepository 对象实际上是由框架生成的一个代理对象,下面我们看下执行结果

SpringBoot系列教程JPA之基础环境搭建的方法

5. 小结

从上面的步骤下来,会发现搭建一个jpa的项目工程属于比较简单的过程,添加必要的依赖,稍微注意的是两个

  • 创建一个POJO 与我们实际的表关联起来
  • 创建一个RepositoryApi继承自org.springframework.data.repository.CrudRepository
  • 通过IoC/DI方式注入RepositoryApi对象,然后可以愉快的进行db操作

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

SpringBoot集成JPA的示例代码

本文介绍了SpringBoot集成JPA的示例代码,分享给大家,具体如下:

1.创建新的maven项目

SpringBoot集成JPA的示例代码

2. 添加必须的依赖

  <!--springboot的必须依赖-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
  </parent>

  <dependencies>
    <!--启动springmvc的相关配置,springboot的自动配置-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--jpa-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
    </dependency>
  </dependencies>

3. 新建springboot启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class,args);
  }
}

4. 在resources跟目录下新建application.properties

#建立/更新数据表的配置
spring.jpa.hibernate.ddl-auto=update
#数据库地址
spring.datasource.url=jdbc:mysql://localhost:3306/qian?useUnicode=true&characterEncoding=utf-8
#数据库用户名
spring.datasource.username=root
#数据库密码
spring.datasource.password=123
  1. update:Hibernate根据给定的Entity结构改变数据库。
  2. create: 每次都会创建数据库,关闭时不会删除
  3. none: mysql的默认设置 , 不改变数据结构
  4. create-drop: 创建数据库,但是每次sessionFactory关闭后都会删除

5. 新建实体类User

这个时候其实已经可以启动springboot, 但是不会生成数据表,因为还没有配置实体类的jpa

SpringBoot集成JPA的示例代码

先新建user.java

import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
 * Created by Andy on 2018/1/20.
 */
//表明这是个需要生成数据表的类
@Entity
public class User {
//  定义主键id
  @Id
//  声明一个策略通用生成器,name为”system-uuid”,策略strategy为”uuid”。
  @GenericGenerator(name = "system-uuid", strategy ="uuid")
//  用generator属性指定要使用的策略生成器。
  @GeneratedValue(generator = "system-uuid")
  private String id;
  private String name;
  private Integer age;
  private Boolean sex;

  public String getId() {
    return id;
  }

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

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Integer getAge() {
    return age;
  }

  public void setAge(Integer age) {
    this.age = age;
  }

  public Boolean getSex() {
    return sex;
  }

  public void setSex(Boolean sex) {
    this.sex = sex;
  }
}

这时候启动项目,就会在指定位置下生成一个user数据表

SpringBoot集成JPA的示例代码

6. 实现CRUD

CrudRepository是一个提供了普通增删改查方法的接口,由spring内部提供,我们只需调用即可

@NoRepositoryBean
public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {
  <S extends T> S save(S var1);
  <S extends T> Iterable<S> save(Iterable<S> var1);
  T findOne(ID var1);
  boolean exists(ID var1);
  Iterable<T> findAll();
  Iterable<T> findAll(Iterable<ID> var1);
  long count();
  void delete(ID var1);
  void delete(T var1);
  void delete(Iterable<? extends T> var1);
  void deleteAll();
}

新建UserRepository.java

public interface UserRepository extends CrudRepository<User, String> {

}

7. 实现controller控制

新建UserController.java

@RestController
public class UserController {
  @Autowired
  private UserRepository userRepository;

  @RequestMapping("/add")
  public User add(String name){
    User user = new User();
    user.setName(name);
    return userRepository.save(user);
  }

  @RequestMapping("/list")
  public Iterable<User> list(){
    Iterable<User> all = userRepository.findAll();
    return all;
  }
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

以上就是本次给大家分享的全部知识点内容总结,大家还可以在下方相关文章里找到儿童python编程入门书籍推、 解决axios.interceptors.respon、 vue项目中使用md5加密以及、 等java文章进一步学习,感谢大家的阅读和支持。

上一篇:Java基本数据类型不需要进行创建对象的原因

下一篇:Java语言中一个字符占的字节数详解

展开 +

收起 -

学习笔记
网友NO.359606

理解JPA注解@GeneratedValue的使用方法

一、JPA通用策略生成器 通过annotation来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法, JPA提供四种标准用法,由@GeneratedValue的源代码可以明显看出. Target({METHOD,FIELD}) @Retention(RUNTIME) public @interface GeneratedValue{ GenerationType strategy() default AUTO; String generator() default ""; } 其中GenerationType: public enum GenerationType{ TABLE, SEQUENCE, IDENTITY, AUTO } JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO. TABLE:使用一个特定的数据库表格来保存主键。 SEQUENCE:根据底层数据库的序列来生成主键,条件是数据库支持序列。 IDENTITY:主键由数据库自动生成(主要是自动增长型) AUTO:主键由程序控制。 TABLE比较复杂,这里不讲解。分别介绍其他三个: 1.SEQUENCE 实体类中的注解 @Id @GeneratedValue(strategy =GenerationType.SEQUENCE,generator="aaa") @SequenceGenerator(name="aaa", sequenceName="seq_payment") @SequenceGenerator定义 @Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME) public @interface SequenceGenerator { String name(); String sequenceName() default ""; int initialValue() default 0; int allocationSize() default 50; } name属性表示该表主键生成策略的名称,它被引用在@GeneratedValue中设置的“generator”值中。 sequenceName属性表示生成策略用到的数据库序列名称。……

网友NO.649975

SpringBoot集成JPA的示例代码

本文介绍了SpringBoot集成JPA的示例代码,分享给大家,具体如下: 1.创建新的maven项目 2. 添加必须的依赖 !--springboot的必须依赖-- parent groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-parent/artifactId version1.5.9.RELEASE/version /parent dependencies !--启动springmvc的相关配置,springboot的自动配置-- dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-web/artifactId /dependency !--jpa-- dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-data-jpa/artifactId /dependency !--mysql驱动-- dependency groupIdmysql/groupId artifactIdmysql-connector-java/artifactId /dependency /dependencies 3. 新建springboot启动类 import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplicationpublic class Application { public static void main(String[] args) { SpringApplication.run(Application.class,args); }} 4. 在resources跟目录下新建application.properties #建立/更新数据表的配置spring.jpa.hibernate.ddl-auto=update#数据库地址spring.datasource.url=jdbc:mysql://localhost:3306/qian?useUnicode=trueimport javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;/** * Created by Andy on 2018/1/20. *///表明这是个需要生成数据表的类@Entitypublic class User {// 定义主键id @Id// 声明一个策略通用生成器,name为”sys……

网友NO.285092

让JPA的Query查询接口返回Map对象的方法

在JPA 2.0 中我们可以使用entityManager.createNativeQuery()来执行原生的SQL语句。 但当我们查询结果没有对应实体类时,query.getResultList()返回的是一个ListObject[]。也就是说每行的数据被作为一个对象数组返回。 常见的用法是这样的: public void testNativeQuery(){ Query query = entityManager.createNativeQuery("select id, name, age from t_user"); List rows = query.getResultList(); for (Object row : rows) { Object[] cells = (Object[]) row; System.out.println("id = " + cells[0]); System.out.println("name = " + cells[1]); System.out.println("age = " + cells[2]); }} 这样用会使代码非常不容易让人理解, 究竟下标为0的元素到底是什么, 不去数查询语句是不知道的,而且一旦查询语句被调整,Java代码也要一起调整。这时候我们想如果返回的是Map的话,用起来会清晰的多。 可惜的是JPA的API中并没有提供这样的设置。其实很多JPA的底层实现都是支持返回Map对象的。 例如: EclipseLink的query.setHint(QueryHints.RESULT_TYPE, ResultType.Map); Hibernate的.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP); 所以,如果我们想要返回Map并且确定底层用的是某一种JPA的实现时我们可以退而求其次, 牺牲跨实现的特性来满足我们的需求: public void testNativeQuery(){ Query query = entityManager.createNativeQuery("select id, name, age from t_user"); query.unwrap(SQLQuery.class).setResultT……

网友NO.307394

springboot使用spring-data-jpa操作MySQL数据库

我们在上一篇搭建了一个简单的springboot应用,这一篇将介绍使用spring-data-jpa操作数据库。 新建一个MySQL数据库,这里数据库名为springboot,建立user_info数据表,作为我们示例操作的表对象。 user_info信息如下: DROP TABLE IF EXISTS `user_info`;CREATE TABLE `user_info` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(255) DEFAULT NULL, `password` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`)) ENGINE=MyISAM AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;-- ------------------------------ Records of user_info-- ----------------------------INSERT INTO `user_info` VALUES ('1', 'Java之音', '12345');INSERT INTO `user_info` VALUES ('2', '张无忌', '123'); 数据库及表创建成功后,回到我们的工程中 第零步,首先引入MySQL及jpa的maven依赖包: dependency groupIdmysql/groupId artifactIdmysql-connector-java/artifactId /dependency dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-data-jpa/artifactId /dependency 第一步,在yml配置文件中配置数据库连接信息: spring: datasource: driver-class-name: com.mysql.jdbc.Driver url: jdbc:mysql://localhost:3306/springboot?useUnicode=trueuseSSL=false username: root password: 1011 jpa: show-sql: true 第二步,创建一个实体类,对应数据表实体映射: package com.javazhiyin;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.pe……

<
1
>

Copyright 2018-2019 xz577.com 码农之家

版权责任说明