我们先来了解一下是什么是springboot jpa,springboot jpa的入门又是怎么样的呢?
1.springboot jpa是sun公司提供的持久化规范,为java开发人员提供了一种对象/关联映射工具来 管理java应用中的关系数据。它主要表现是为了简化现有的持久化开发工作和整合ORM技术,结habernate、toplink、JDO等ORM框架各自为营的局面。
2.Spring Boot Jpa 是 Spring 基于 ORM 框架、Jpa 规范的基础上封装的一套 Jpa 应用框架,可使开发者用极简的代码即可实现对数据的访问和操作。它提供了包括增删改查等在内的常用功能,且易于扩展!学习并使用 Spring Data Jpa 可以极大提高开发效率!
Spring Boot Jpa 让我们解脱了 DAO 层的操作,基本上所有 CRUD 都可以依赖于它来实现
注意:Jpa 是一套规范,不是一套产品,那么像 Hibernate,TopLink,JDO 他们是一套产品,如果说这些产品实现了这个 Jpa 规范,那么我们就可以叫他们为 Jpa 的实现产品。
3.了解一下Spring Data jpa
SpringData为我们提供使用统的API来对数据访问层进行操作;这主要是Spring Data Commons项目来实现的。Spring Data Commons让我们在使用关系型或者非关系型数据访问技术时都基于Spring提供的统一标准,标准包含了CRUD(创建、获取、更新、删除)、查询、排序和分页的相关操作。
4.统一的Repository接口
Repository<T, ID extends Serializable> : 统一接口
RevisionRepository<T, ID extends Serializable, N extends Number & Comparable> :
基于乐观锁机制CrudRepository<T, ID extends Serializable> : 基本CRUD操作
PagingAndSortingRepository<T, ID extends Serializable> :基本CRUD及分页
了解完基本的概念之后,我们就开始进行一个小小的案例吧:
我们首先配置一下配置文件,由于springboot Data 脱离Dao操作,所以,我们只需要有一个库,便能自动生成相应的数据表,而这些,只需要在springboot 中的配置文件中实现(以application.poroerties为例)
spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#hibernate的ddl操作
spring.jpa.hibernate.ddl-auto=create
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
#显示sql的执行
spring.jpa.show-sql=true
#格式化数据库的语句
spring.jpa.properties.hibernate.format_sql=true
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
配置好这些,自己创建一个model,在model里面创建数据库表(类名)
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.io.Serializable;
@Entity//引入jpa的映射关系
public class User {
@Id//生成主键
@GeneratedValue(strategy = GenerationType.IDENTITY) //自增主键
private Long id;
@Column(nullable = false, unique = true)
private String userName;
@Column(nullable = false)
private String passWord;
@Column(nullable = false, unique = true)
private String email;
@Column(nullable = true, unique = true)
private String nickName;
@Column(nullable = false)
private String regTime;
public User() {
}
public User(String userName, String passWord, String email, String nickName, String regTime) {
this.userName = userName;
this.passWord = passWord;
this.email = email;
this.nickName = nickName;
this.regTime = regTime;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public String getRegTime() {
return regTime;
}
public void setRegTime(String regTime) {
this.regTime = regTime;
}
}
- 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
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
注意: 既然是SpringBoot Data Jpa 就应该有相应的驻注解需要特别注意
@Entity//引入jpa的映射关系
@GeneratedValue(strategy = GenerationType.IDENTITY)//生成的主键类型
- 1
- 2
接下来,我们就去实现
import com.neo.model.User;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Slice;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
public interface UserRepository extends JpaRepository<User, Long> {
User findByUserName(String userName);
User findByUserNameOrEmail(String username, String email);
//超时处理
@Transactional(timeout = 10)
@Modifying
@Query("update User set userName = ?1 where id = ?2")
int modifyById(String userName, Long id);
@Transactional
@Modifying
@Query("delete from User where id = ?1")
void deleteById(Long id);
@Query("select u from User u where u.email = ?1")
User findByEmail(String email);
@Query("select u from User u")
Page<User> findALL(Pageable pageable);
Page<User> findByNickName(String nickName, Pageable pageable);
Slice<User> findByNickNameAndEmail(String nickName, String email,Pageable pageable);
}
- 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
我来解释一下里面的一些比较重要的东西:
首先是继承JpaRepository<T, ID>
,由于springboot底层实现了自动化配置,所以我们调用jpa的使用接口就行了。
接着就是几个注解:@Transactional、@Modifying 、@Query
这几个注解为什么会出现在这里面@Transactional
:是事务的声明,是说明这个方法是一个事务,在后面调用时,将操作与事务有关的东西;@Modifying
注解在@Query注解中编写JPQL实现DELETE
和UPDATE
操作的时候必须加上@modifying
注解,以通知Spring Data 这是一个DELETE
或UPDATE
操作,UPDATE
或者DELETE
操作需要使用事务。
注意JPQL不支持INSERT操作。
最后,我们建立一个测试类:
import com.neo.model.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.junit4.SpringRunner;
import javax.annotation.Resource;
import java.text.DateFormat;
import java.util.Date;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserRepositoryTests {
@Resource
private UserRepository userRepository;
@Test
public void testSave() {
//转义时间
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
String formattedDate = dateFormat.format(date);
userRepository.save(new User("aa", "aa123456","aa@126.com", "aa", formattedDate));
userRepository.save(new User("bb", "bb123456","bb@126.com", "bb", formattedDate));
userRepository.save(new User("cc", "cc123456","cc@126.com", "cc", formattedDate));
// Assert.assertEquals(3, userRepository.findAll().size());
// Assert.assertEquals("bb", userRepository.findByUserNameOrEmail("bb", "bb@126.com").getNickName());
// userRepository.delete(userRepository.findByUserName("aa"));
}
@Test
public void testBaseQuery() {
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
String formattedDate = dateFormat.format(date);
User user=new User("ff", "ff123456","ff@126.com", "ff", formattedDate);
userRepository.findAll();
userRepository.findById(3L);
userRepository.save(user);
user.setId(2L);
userRepository.delete(user);
userRepository.count();
userRepository.existsById(3L);
}
@Test
public void testCustomSql() {
userRepository.modifyById("cc",3L);
userRepository.deleteById(3L);
userRepository.findByEmail("ff@126.com");
}
@Test
public void testPageQuery() {
int page=1,size=2;
Sort sort = new Sort(Sort.Direction.DESC,"id");
Pageable pageable = PageRequest.of(page,size,sort);
userRepository.findALL(pageable);
userRepository.findByNickName("cc", pageable);
System.out.println(pageable);
}
}
- 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
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
打开数据库,就能见你到自己里面所添加的数据。
以上借鉴了(纯洁的微笑)经验的分享:http://www.ityouknow.com/springboot/2016/08/20/spring-boot-jpa.html