1
2
3
4
5
6
7
8
9
public interface PersonRepositoryByName extends Repository<Person,Integer> {
//一定注意下方法名：findBy(关键字)+属性名（首字母大写）
List<Person> findByName(String name);//按照姓名查找
List<Person> findByAddress(String address);//按照地址查找
List<Person> findByNameOrAge(String name,Integer age);//按照姓名或者年龄查找
List<Person> findByNameLike(String name);//按照姓名模糊查找
List<Person> findByAddressLike(String address);//按照地址模糊查找
}

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
@SpringBootTest
class SpringbootSpringdatajpaApplicationTests {
@Autowired
PersonRepository personRepository;
@Autowired
PersonRepositoryByName personRepositoryByName;
@Test
public void testSave() {
Person person = new Person();
person.setAge(24);
person.setName("张三");
person.setAddress("济南市槐荫区");
this.personRepository.save(person);
}
@Test
public void testFindByName() {
List<Person> list = this.personRepositoryByName.findByName("张三");
for (Person persons : list) {
System.out.println(persons);
}
}
@Test
public void testFindByAddress() {
List<Person> list = this.personRepositoryByName.findByAddress("济南市历下区");
for (Person persons : list) {
System.out.println(persons);
}
}
@Test
public void testFindByNameOrAge() {
List<Person> list = this.personRepositoryByName.findByNameOrAge("李四",21);
for (Person persons : list) {
System.out.println(persons);
}
}
@Test
public void testFindByNameLink() {
List<Person> list = this.personRepositoryByName.findByNameLike("李%");
for (Person persons : list) {
System.out.println(persons);
}
}
@Test
public void testFindByAddressLink() {
List<Person> list = this.personRepositoryByName.findByAddressLike("济南市%");
for (Person persons : list) {
System.out.println(persons);
}
}
}

1
2
3
4
5
6
7
8
9
10
public interface PersonRepositoryQueryAnnotation extends Repository<Person,Integer> {
//使用@Query注解结合sql语句来实现查找，**注意**：？的顺序和形参的顺序是一一对应的
nativeQuery=true的意思是告诉hibernate这是一个标准的sql语句
@Query(value = "select * from tb_person where name=?",nativeQuery = true)
List<Person> queryByName(String name);
@Query(value = "update tb_person set name=? where id=?",nativeQuery = true)
@Modifying//这是更新的注解与@Query注解配合使用来更新
void updateNameById(String name,Integer id);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void testQueryByName() {
List<Person> list = this.personRepositoryQueryAnnotation.queryByName("张三");
for (Person persons : list) {
System.out.println(persons);
}
}
@Test
@Transactional//手动设置一个事务，更新操作必须在事务中
@Rollback(value = false)//取消自动回滚
public void testUpdateNameById() {
this.personRepositoryQueryAnnotation.updateNameById("张三三",3);
}
}

1
2
3
public interface CrudRepository extends org.springframework.data.repository.CrudRepository<Person,Integer> {
}

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
//插入数据
@Test
public void testInsert() {
Person person=new Person();
person.setName("张三丰");
person.setAddress("青岛市");
person.setAge(333);
crudRepository.save(person);
}
//注意CrudRepository的save方法既可以插入又可以更新
@Test
public void testInsert() {
Person person=new Person();、
//**注意**：如果你想要更新的话必须指定id，使用setId()方法
person.setId(4);
person.setName("张三丰");
person.setAddress("青岛市黄岛区");
person.setAge(333);
crudRepository.save(person);
}
//按照Id进行指定删除
@Test
public void testDeleteById() {
crudRepository.deleteById(5);
}
//按照指定Id进行查找
@Test
public void testFindById() {
Optional<Person> persons = crudRepository.findById(4);
System.out.println(persons);
}
//查找全部
@Test
public void testFindAll() {
Iterable<Person> all = crudRepository.findAll();
System.out.println(all);
}

1
2
3
public interface RepositoryPagingAndSorting extends PagingAndSortingRepository<Person,Integer> {
}

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
//排序查询
@Test
public void testSort() {
//Order来定义排序规则DESC是降序，ASC是升序
Order order=new Order(Sort.Direction.DESC,"id");
//spring boot2.0以上版本的Sort重写了，不能new Sort了，要用Sort.by
Sort sort=Sort.by(order);
List<Person> persons = (List<Person>) repositoryPagingAndSorting.findAll(sort);
for (Person list: persons
) {
System.out.println(list);
}
}
//分页查询
@Test
public void testPaging() {
//spring boot2.0以上版本不能用Pageable了要使用PageRequest.of，返回PageRequest
PageRequest pageable=PageRequest.of(1,2);
Page<Person> page = repositoryPagingAndSorting.findAll(pageable);
System.out.println("总条数"+page.getTotalElements());
System.out.println("总页数"+page.getTotalPages());
List<Person> list = page.getContent();
for (Person persons:list
) {
System.out.println(persons);
}
}
//分页排序查询（将上面两个方法结合）
@Test
public void testPagingAndSort() {
Order order=new Order(Sort.Direction.DESC,"id");
Sort sort=Sort.by(order);
PageRequest pageable= PageRequest.of(0,2,sort);
Page<Person> page = repositoryPagingAndSorting.findAll(pageable);
System.out.println("总条数"+page.getTotalElements());
System.out.println("总页数"+page.getTotalPages());
List<Person> list = page.getContent();
for (Person persons:list
) {
System.out.println(persons);
}
}

1
2
3
public interface PersonRepository extends JpaRepository<Person,Integer>{
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//分页查询
@Test
public void testJpaRepository() {
Sort sort=Sort.by(Sort.Direction.DESC,"id");
PageRequest pageable=PageRequest.of(0, 2,sort);
Page<Person> page = personRepository.findAll(pageable);
List<Person> list = page.getContent();
for (Person persons:list
) {
System.out.println(persons);
}
}
//按照顺序查询
@Test
public void testJpaRepositoryFind() {
Sort sort = Sort.by(Sort.Direction.DESC, "id");
//注意这里的personRepository.findAll(sort)不需要进行强制类型转换，因为JpaRepository实现了对父接口的返回值类型的适配
List<Person> list = personRepository.findAll(sort);
for (Person persons : list
) {
System.out.println(persons);
}
}

1
2
3
public interface RepositoryJpaSe extends JpaSpecificationExecutor<Person>/*只需要写实体类*/,JpaRepository<Person,Integer>{
}

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
//单条件查询
@Test
public void testJpaSe() {
Specification spe=new Specification() {
@Override
/**root是我们实体类的一个封装类
*	criteriaQuery:封装了我们要执行的查询中的各个部分的信息
*	criteriaBuilder：定义不同的查询条件
*/
public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder criteriaBuilder) {
Predicate predicate = criteriaBuilder.equal(root.get("name"), "张三三");
return predicate;
}
};
Optional list = repositoryJpaSe.findOne(spe);
System.out.println(list);
}
//多条件查询
@Test
public void testJpaSpe() {
Specification spe=new Specification() {
@Override
public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder criteriaBuilder) {
//多条件查询的时候我们就将我们的多个查询条件放进Predicate类型的List中
Predicate name = criteriaBuilder.equal(root.get("name"), "李四");
Predicate age = criteriaBuilder.equal(root.get("age"), 24);
List<Predicate> list=new ArrayList<>();
list.add(name);
list.add(age);
Predicate[] pre=new Predicate[list.size()];
//将list中的数据注入到一个Predicate类型的数组中,其中or是或者的关系，and是并列的关系
return criteriaBuilder.or(list.toArray(pre));
}
};
List list = repositoryJpaSe.findAll(spe);
System.out.println(list);
}
//多条件查询并且排序
@Test
public void testJpaSpe1() {
Specification spe=new Specification() {
@Override
public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder criteriaBuilder) {
//注意可以这样来写我们的多个条件，这样写比较方便简洁
return criteriaBuilder.or(criteriaBuilder.equal(root.get("name"),"张三丰"),criteriaBuilder.equal(root.get("age"),333),criteriaBuilder.equal(root.get("id"),2));
}
};
Sort sort=Sort.by(Sort.Direction.DESC,"id");
List list = repositoryJpaSe.findAll(spe, sort);
System.out.println(list);
}
//多条件查询并且分页查询
@Test
public void testJpaSpe2() {
Specification spe=new Specification() {
@Override
public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder criteriaBuilder) {
//注意可以将and和or条件组合使用
return criteriaBuilder.or(criteriaBuilder.equal(root.get("name"),"张三丰"),criteriaBuilder.equal(root.get("age"),333),criteriaBuilder.equal(root.get("id"),2));
}
};
Sort sort=Sort.by(Sort.Direction.DESC,"id");
PageRequest pageable=PageRequest.of(0,1,sort);
Page<Person> people = repositoryJpaSe.findAll(spe,pageable);
List<Person> list = people.getContent();
System.out.println(list);
}

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
//roles
角色的实体类
@Entity
@Table(name="tb_roles")
public class Roles {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="roles_id")
private Integer roles_id;
@Column(name="role_name")
private String roles_name;
/**OneToMany:这个实体类是一个对应多个，一个角色分配给多个用户，所以对于这个实体类来说就是一对多
*mappedBy：
*fetch=FetchType.EAGER：关闭懒加载，否则的话会报错，说创建会话失败
*/
@OneToMany(mappedBy = "roles",fetch=FetchType.EAGER)
//对应多个Person对象所以就用一个set集合来存放多个Person对象
private Set<Person> persons=new HashSet<>();
public Set<Person> getPersons() {
return persons;
}
public void setPersons(Set<Person> persons) {
this.persons = persons;
}
public Integer getRoles_id() {
return roles_id;
}
public void setRoles_id(Integer roles_id) {
this.roles_id = roles_id;
}
public String getRoles_name() {
return roles_name;
}
public void setRoles_name(String roles_name) {
this.roles_name = roles_name;
}
@Override
public String toString() {
return "Roles{" +
"roles_id=" + roles_id +
", roles_name='" + roles_name + ''' +
'}';
}

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
//person
用户的实体类
@Entity
@Table(name="tb_person")
public class Person {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Integer id;
@Column(name = "age")
private Integer age;
@Column(name = "name")
private String name;
@Column(name = "address")
private String address;
//多个角色对应一个用户，所以用ManyToOne
//cascade = CascadeType.PERSIST：开启级联：创建角色的时候也创建用户
@ManyToOne(cascade = CascadeType.PERSIST)
//@JoinColumn：外键关联，person实体类中和roles关联的属性为rolesId
@JoinColumn(name = "rolesId")
private Roles roles;
public Roles getRoles() {
return roles;
}
public void setRoles(Roles roles) {
this.roles = roles;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", age=" + age +
", name='" + name + ''' +
", address='" + address + ''' +
'}';
}
}

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
@SpringBootTest
public class OneToManyTest {
@Autowired
PersonRepository repository;
@Test
/*添加的步骤如下：
*
1.创建角色
*	2.创建用户
*	3.建立关联
*	4.保存
*/
public void testOneToMany(){
//创建一个角色
Roles roles=new Roles();
roles.setRoles_name("鬼剑士");
//创建一个用户
Person person=new Person();
person.setAge(19);
person.setAddress("济南市莱芜区");
person.setName("李小龙");
//设置关系
roles.getPersons().add(person);
//一对多的关系中的时候，多对一的哪=那一方就用set方法，一对多的那一方就用get .add方法
person.setRoles(roles);
//要开启person实体类的级联关系
repository.save(person);
}
//查询操作
@Test
public void testOneToManyFind(){
//按照person的id查找person，然后获取person中的roles，注意，在这个过程中执行 System.out.println语句后其实已经关闭了person这个实体类，所以我们需要关闭hibernate的懒加载
Optional<Person> person = repository.findById(7);
System.out.println(person);
Roles roles = person.get().getRoles();
System.out.println(roles.getRoles_name());
}
}

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
//roles
角色的实体类
@Entity
@Table(name="tb_roles")
public class Roles {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="roles_id")
private Integer roles_id;
@Column(name="role_name")
private String roles_name;
/* @ManyToMany：多对多的关系
*cascade = CascadeType.PERSIST：开启级联操作，创建角色的时候也创建武器
*fetch = FetchType.EAGER：关闭懒加载
*/
@ManyToMany(cascade = CascadeType.PERSIST,fetch = FetchType.EAGER)
/*
*@JoinTable：创建一个中间表，用来映射这两个多对多的实体类
*name：指定中间表的名称
*joinColumns：当前实体类和中间表中外键关联的属性，joinColumns = @JoinColumn(name="roles_id")：当前这个实体类中的外	*键和中间表中的roles_id对应
*inverseJoinColumns：另一个实体类中的外键对应的属性
*/
@JoinTable(name="tb_roles_weapons",joinColumns = @JoinColumn(name="roles_id"),inverseJoinColumns =@JoinColumn(name="weapons_id"))
private Set<Weapons> weapons=new HashSet<>();
public Integer getRoles_id() {
return roles_id;
}
public void setRoles_id(Integer roles_id) {
this.roles_id = roles_id;
}
public String getRoles_name() {
return roles_name;
}
public void setRoles_name(String roles_name) {
this.roles_name = roles_name;
}
public Set<Weapons> getWeapons() {
return weapons;
}
public void setWeapons(Set<Weapons> weapons) {
this.weapons = weapons;
}
@Override
public String toString() {
return "Roles{" +
"roles_id=" + roles_id +
", roles_name='" + roles_name + ''' +
'}';
}
}

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
//weapons
武器的实体类
@Entity
@Table(name="tb_weapons")
public class Weapons {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="id")
private Integer id;
@Column(name="name")
private String name;
@Column(name="price")
private Integer price;
//多对多的操作中，在另一个实体类中只需要用一个@ManyToMany注释就好了
//mappedBy：这个属性的值就是我们当前实体类对应的另一个实体类中的对应的当前这个实体类的属性
@ManyToMany(mappedBy = "weapons")
private Set<Roles> roles=new HashSet<>();
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
public Set<Roles> getRoles() {
return roles;
}
public void setRoles(Set<Roles> roles) {
this.roles = roles;
}
@Override
public String toString() {
return "Weapons{" +
"id=" + id +
", name='" + name + ''' +
", price=" + price +
'}';
}
}

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
/**
*保存的步骤：
*1.建立角色实体类
*2.建立武器实体类
*3.建立关系
*4.保存
*/
@SpringBootTest
public class ManyToManyTest {
@Autowired
RepositoryRolesAndWeapons repositoryRolesAndWeapons;
@Test
public void testSave(){
//建立角色
Roles r1=new Roles();
r1.setRoles_name("圣职者");
//建立武器
Weapons w1=new Weapons();
w1.setName("十字架");
w1.setPrice(500);
//建立联系
r1.getWeapons().add(w1);
w1.getRoles().add(r1);
//保存
repositoryRolesAndWeapons.save(r1);
}
@Test
public void testFind(){
Optional<Roles> roles = repositoryRolesAndWeapons.findById(2);
System.out.println(roles);
//注意不要忘记关闭懒加载
Set<Weapons> weapons=roles.get().getWeapons();
for (Weapons weapon:weapons
) {
System.out.println(weapon);
}
}
}