施坤的博客
0%

spring orm的映射关系

发表于 更新于 分类于 阅读次数： Valine：

说明

hibernate

一对一

  • 配置基本不变
  • 实体类，一个人对应一个信用卡
1
2
3
4
5
6
7
8
9
10
package xyz.shi.domain;
import javax.persistence.*;
@Entity
@Table(name = "t_idcard")
public class IdCard {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String cardNo;
.....
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
ckage xyz.shi.domain;

import javax.persistence.*;

@Entity
@Table(name = "t_person")
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    // 单向关联只要向子表加入关系
    @OneToOne
    @JoinColumn(name = "t_idCard_id")
    private IdCard idCard;
    ...

只做了单向关联

  • dao
1
2
3
4
5
6
7
8
9
10
11
12
13
package xyz.shi.dao;

import xyz.shi.domain.QueryResult;
import xyz.shi.domain.Person;

public interface PersonDao {
    void save(Person person);
    void update(Person person);
    Person findById(int id);
    QueryResult findAll(int firstResult, int maxResults);
    void delete(Person person);
}

  • 实现dao
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
package xyz.shi.dao.Impl;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import xyz.shi.dao.PersonDao;
import xyz.shi.domain.Person;
import xyz.shi.domain.QueryResult;
import xyz.shi.domain.User;
import java.util.List;

@Repository
public class PersonDaoImpl implements PersonDao {
    @Autowired
    private SessionFactory sessionFactory;
    @Override
    public void save(Person person) {
        Session session = sessionFactory.getCurrentSession();
        session.save(person);

    }

    @Override
    public void update(Person person) {
        Session session = sessionFactory.getCurrentSession();
        session.update(person);
    }

    @Override
    public Person findById(int id) {
        Session session = sessionFactory.getCurrentSession();
        Person person = session.get(Person.class, id);
        return person;
    }
    @Override
    public QueryResult findAll(int firstResult, int maxResults) {
        Session session = sessionFactory.getCurrentSession();

        List<User> list = session.createQuery(
                        "FROM Person")
                .setFirstResult(firstResult)
                .setMaxResults(maxResults)
                .list();
        Long count = (Long)session.createQuery( //
                        "SELECT COUNT(*) FROM User") //
                .uniqueResult();
        return new QueryResult(count.intValue(), list);
    }

    @Override
    public void delete(Person person) {
        Session session = sessionFactory.getCurrentSession();
        session.delete(person);
    }
}

  • 测试
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
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import xyz.shi.dao.PersonDao;
import xyz.shi.domain.IdCard;
import xyz.shi.domain.Person;
import xyz.shi.domain.QueryResult;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class PersonTest {
    @Autowired
    private PersonDao dao;

    @Test
    @Transactional
//    @Rollback(false) // 不需要回滚
    public void save() {
        IdCard idCard = new IdCard();
        idCard.setId(17);
        Person person = new Person();
        person.setName("王大伟7");
        person.setIdCard(idCard);
        dao.save(person);
    }
    @Test
    @Transactional
//    @Rollback(false) 
    public void find() {
        QueryResult result = dao.findAll(0, 5);
        System.out.println(result.getCount());
        for (Object o : result.getList()) {
            Person person = (Person) o;
            System.out.println(person.getName());
            System.out.println(person.getIdCard().getCardNo());
        }

    }
    @Test
    @Transactional
    @Rollback(false)
    public void update() {
        IdCard idCard = new IdCard();
        idCard.setId(17);
        Person person = new Person();
        person.setName("王大伟16");
        person.setIdCard(idCard);
        person.setId(16);
        dao.update(person);
    }
}

一对多

  • 准备两个实体类，一个班级下有多个学生
  • 班级实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package xyz.shi.domain;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "grade")
public class Grade {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer Id;
    private String name;
    //持有 Student 引用的集合，来维护一对多关联关系
    @OneToMany(mappedBy = "grade", cascade = CascadeType.ALL)
    private Set<Student> students = new HashSet<>();
...
  • 学生实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
@Entity
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    //持有实体类 Grade 的一个引用，维护多对一关系
    // 多对一关联关系
    @ManyToOne
    @JoinColumn(name = "grade")
    private Grade grade;
    ....
  • dao
1
2
3
4
public interface StudentDao {
    void save(Student student);
    QueryResult findAll(int firstResult, int maxResults);
}
  • 实现
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

@Repository
public class StudentDaoImpl implements StudentDao {
    @Autowired
    private SessionFactory sessionFactory;
    @Override
    public void save(Student student) {
        Session session = sessionFactory.getCurrentSession();
        session.save(student);
    }

    @Override
    public QueryResult findAll(int firstResult, int maxResults) {
        Session session = sessionFactory.getCurrentSession();
        List<Object[]> list = session.createQuery( //
                        "select s, g from Student s join s.grade g") //
                .setFirstResult(firstResult) //
                .setMaxResults(maxResults) //
                .list();

        // 查询总记录数
        Long count = (Long) session.createQuery( //
                        "SELECT COUNT(*) FROM Student") //
                .uniqueResult();
        return new QueryResult(count.intValue(), 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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class StudentTest {
    @Autowired
    private StudentDao studentDao;

    @Test
    @Transactional
//    @Rollback(false) // 不需要回滚
    public void save() {
        Grade grade = new Grade();
        grade.setId(36);

        Student student = new Student();
        student.setName("王大伟36");
        //设置学生的班级
        student.setGrade(grade);

        Student student2 = new Student();
        student2.setGrade(grade);
        student2.setName("小红36");

        studentDao.save(student);
        studentDao.save(student2);
    }
    @Test
    @Transactional
    public void findAll() {
        QueryResult result = studentDao.findAll(0, 5);
        System.out.println(result.getCount());
        List<Object[]> list  = result.getList();
        for (Object[] arr : list) {
            Student student = (Student) arr[0];
            System.out.println("Student: " + student.getName() + ", Grade: " + student.getGrade().getName());

        }
    }

多对多

  • 多个学生和多个课程
  • 学生实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Entity
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    //持有实体类 Grade 的一个引用，维护多对一关系
    // 多对一关联关系
    @ManyToOne
    @JoinColumn(name = "gid")
    private Grade grade;
    //将 Course 对象的集合作为其属性，以维护它们之间的多对多关联关系
    @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinTable(
            name = "student_course",
            joinColumns = @JoinColumn(name = "student_id"),
            inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();

@JoinColumn(name = “gid”) 这里的name对应数据表中的字段，若填的字段在数据表中不存在，就会自动创建

  • 课程类
1
2
3
4
5
6
7
8
9
10
@Entity
@Table(name = "course")
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    //学生 Student 的集合作为其属性，维护多对多关联关系
    @ManyToMany(mappedBy = "courses")
    private Set<Student> students = new HashSet<>();

​ @ManyToMany(mappedBy = “courses”) 这里的courses对应Student实体类中的courses

  • dao
1
2
3
4
public interface StudentManyToManyDao {
    void save(Student student);
    QueryResult findAll(int firstResult, int maxResults);
}
  • 实现dao
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

@Repository
public class StudentManyToManyDaoImpl implements StudentManyToManyDao {
    @Autowired
    private SessionFactory sessionFactory;
    @Override
    public void save(Student student) {
        Session session = sessionFactory.getCurrentSession();
        session.save(student);
    }

    @Override
    public QueryResult findAll(int firstResult, int maxResults) {
        Session session = sessionFactory.getCurrentSession();
        String hql = "SELECT s, c, g FROM Student s " +
                "JOIN s.courses c " +
                "JOIN s.grade g";
        List<Object[]> list = session.createQuery(hql)
                .setFirstResult(firstResult)
                .setMaxResults(maxResults)
                .list();

        // 查询总记录数
        Long count = (Long) session.createQuery( //
                        "SELECT COUNT(*) FROM Student") //
                .uniqueResult();
        return new QueryResult(count.intValue(), 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
45
46
47
48
49
50
51
52
53
54
55
56
57
58

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class StudentManyToManyTest {
    @Autowired
    private StudentManyToManyDao studentDao;
    @Test
    @Transactional
    @Rollback(false) // 不需要回滚
    public void save() {
        //-----新增两个学生，关联到一个班级下面，同时新增的两个学生关联不同的课程（需要用到第三方表）

        //一个班级
        Grade grade = new Grade();
        grade.setId(36);
        // 新建两个学生
        Student student1 = new Student();
        student1.setName("王大伟36121");
        //设置学生的班级
        student1.setGrade(grade);

        Student student2 = new Student();
        student2.setGrade(grade);
        student2.setName("小红36121");
        // 两个学生各自对应两个课程
        Course course1 = new Course();
        course1.setId(17);

        Course course2 = new Course();
        course2.setId(18);


        studentDao.save(student1);
        studentDao.save(student2);

        //学生选课的关系相互关联
        course1.getStudents().add(student1);
        student1.getCourses().add(course1);

        course2.getStudents().add(student2);
        student2.getCourses().add(course2);
    }
    @Test
    @Transactional
    public void findAll() {
        QueryResult qresult = studentDao.findAll(0, 5);
        System.out.println(qresult.getCount());
        List<Object[]> list  = qresult.getList();
        for (Object[] result : list) {
            Student student = (Student) result[0];
            Course course = (Course) result[1];
            Grade grade = (Grade) result[2];
            System.out.println(student);
            System.out.println(course);
            System.out.println(grade);
        }
    }
}

Jpa

  • 配置不变

一对一

  • 一个人对应一个信用卡号
  • Person实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package xyz.shi.domain;
import javax.persistence.*;
@Entity
@Table(name = "t_person")
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String name;
    // 单向关联只要向子表加入关系
    @OneToOne
//    @OneToOne(cascade=CascadeType.ALL)
    @JoinColumn(name = "t_idCard_id")
    private IdCard idCard;
  • IdCard实体类
1
2
3
4
5
6
7
8
import javax.persistence.*;
@Entity
@Table(name = "t_idcard")
public class IdCard {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String cardNo;
  • personDao
1
2
3
4
5
6
7
package xyz.shi.dao;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import xyz.shi.domain.Person;
public interface PersonDao extends JpaRepository<Person, Integer>, JpaSpecificationExecutor<Person> {
}

  • 测试
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
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import xyz.shi.dao.PersonDao;
import xyz.shi.domain.IdCard;
import xyz.shi.domain.Person;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class PersonTest {
    @Autowired
    PersonDao dao;
    @Test
    public void testFindPage() {
        PageRequest page = PageRequest.of(0, 5, Sort.by(Sort.Order.desc("id")));
        Page<Person> all = dao.findAll(page);
        System.out.println("分页 + 根据id逆序 查询结果: " + all.getContent());
        for(Person person: all) {
            System.out.println(person.getName());
            System.out.println(person.getIdCard().getCardNo());
        }
    }
    @Test
    public void testFindBy() {
        Person person = dao.findById(37).get();
        System.out.println(person.getName() + "_"+ person.getIdCard().getCardNo());
    }
    @Test
    public void save() {
        IdCard idCard = new IdCard();
        idCard.setId(14);
        Person person = new Person();
        person.setName("tttt");
        person.setIdCard(idCard);
        dao.save(person);
    }
    @Test
    public void update() {
        IdCard idCard = new IdCard();
        idCard.setId(17);
        Person person = new Person();
        person.setName("tttt2");
        person.setIdCard(idCard);
        person.setId(38);
        dao.save(person);
    }
    @Test
    public void delete() {
        dao.deleteById(37);
    }
}

一对多 多对多

  • 一个班级下有多个学生
  • 班级实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package xyz.shi.domain;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "grade")
public class Grade {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer Id;
    private String name;
    //持有 Student 引用的集合，来维护一对多关联关系
    @OneToMany(mappedBy = "grade", cascade = CascadeType.ALL)
    private Set<Student> students = new HashSet<>();
    ...
  • 学生实体类
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
package xyz.shi.domain;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    //持有实体类 Grade 的一个引用，维护多对一关系
    // 多对一关联关系
    @ManyToOne
    @JoinColumn(name = "gid")
    private Grade grade;
    //将 Course 对象的集合作为其属性，以维护它们之间的多对多关联关系
    @ManyToMany(targetEntity = Course.class)
    @JoinTable(
            name = "student_course",
            joinColumns = @JoinColumn(name = "student_id"),
            inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();
    ....
  • 测试
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import xyz.shi.dao.StudentDao;
import xyz.shi.domain.Course;
import xyz.shi.domain.Grade;
import xyz.shi.domain.Student;

import java.util.ArrayList;
import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class StudentTest {
    @Autowired
    private StudentDao dao;
    @Test
    public void oneToMany() {
        PageRequest page = PageRequest.of(0, 5, Sort.by(Sort.Order.desc("id")));
        Page<Student> all = dao.findAll(page);
        System.out.println("分页 + 根据id逆序 查询结果: " + all.getContent());
        for(Student student: all) {
            System.out.println(student.getName());
            System.out.println(student.getGrade().getName());
        }
        Grade grade = new Grade();
        grade.setId(36);

        Student student = new Student();
        student.setName("王大伟4");
        //设置学生的班级
        student.setGrade(grade);

        Student student2 = new Student();
        student2.setGrade(grade);
        student2.setName("小红5");

        List<Student> studentList = new ArrayList<>();
        studentList.add(student);
        studentList.add(student2);

        dao.saveAll(studentList);
//        dao.deleteAll();
    }
    @Test
    public void ManyToManyFind() {
        Pageable pageable = PageRequest.of(0, 5);
        Page<Object[]> page = dao.findAllCourse(pageable);

        System.out.println("Page " + page.getNumber() + " of " + page.getTotalPages());
        System.out.println("Total elements: " + page.getTotalElements());

        for(Object[] objects: page.getContent()) {
            Student student = (Student) objects[0];
            Course course = (Course) objects[1];
            Grade grade = (Grade) objects[2];
            System.out.println(student.getName());
            System.out.println(course.getName());
            System.out.println(grade.getName());
        }
    }
    @Test
    public void ManyToManySave() {
        //-----新增两个学生，关联到一个班级下面，同时新增的两个学生关联不同的课程（需要用到第三方表）

        //一个班级
        Grade grade = new Grade();
        grade.setId(36);
        // 新建两个学生
        Student student1 = new Student();
        student1.setName("王大伟7");
        //设置学生的班级
        student1.setGrade(grade);

        Student student2 = new Student();
        student2.setGrade(grade);
        student2.setName("小红71");
        // 两个学生各自对应两个课程
        Course course1 = new Course();
        course1.setId(17);

        Course course2 = new Course();
        course2.setId(18);

        //学生选课的关系相互关联
        course1.getStudents().add(student1);
        student1.getCourses().add(course1);

        course2.getStudents().add(student2);
        student2.getCourses().add(course2);

        dao.save(student1);
        dao.save(student2);
    }
    @Test
    public void ManyToManyUpdate() {
        //一个班级
        Grade grade = new Grade();
        grade.setId(36);


        // 新建两个学生
        Student student1 = new Student();
        student1.setName("王大伟7");
        student1.setId(43);
        //设置学生的班级
        student1.setGrade(grade);

        Student student2 = new Student();
        student2.setGrade(grade);
        student2.setName("小红71");
        student2.setId(45);
        // 两个学生各自对应两个课程
        Course course1 = new Course();
        course1.setId(17);

        Course course2 = new Course();
        course2.setId(18);

        //学生选课的关系相互关联

        // 先移除关联关系
        student1.getCourses().remove(course1);
        course1.getStudents().remove(student1);

        student2.getCourses().remove(course2);
        course2.getStudents().remove(student2);
        // 更新关联关系
        course1.getStudents().add(student1);
        student1.getCourses().add(course1);

        course2.getStudents().add(student2);
        student2.getCourses().add(course2);

        dao.save(student1);
        dao.save(student2);
    }
    @Test
    public void ManyToManyDel() {

        Student student = new Student();
        student.setId(46);

        Course course = new Course();
        course.setId(39);

        // 移除关联关系
        student.getCourses().remove(course);
        course.getStudents().remove(student);

        dao.delete(student);

    }
}

Mybatis

一对一

  • 实体类就沿用IdCard和Person

  • 配置需要加入对应的mapper文件

  • mybatis.xml

1
2
3
4
5
6
!-- sql映射文件的位置 -->
    <mappers>
        <!-- 注册userMapper.xml文件 -->
        <mapper resource="mapper/UserMapper.xml"/>
        <mapper resource="mapper/PersonMapper.xml"/>
    </mappers>
  • application.xml
1
2
3
4
5
6
7
8
9
<!--下面的就是自己定义的service-->
   <!--声明service-->
   <bean id="userService" class="xyz.shi.service.Impl.UserServiceImpl">
       <!--就是上面通过创建的dao对象-->
       <property name="userDao" ref="userDao"/>
   </bean>
   <bean id="personService" class="xyz.shi.service.Impl.PersonServiceImpl">
       <property name="personDao" ref="personDao"/>
   </bean>
  • PersonMapper.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
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="xyz.shi.dao.PersonDao">
    <!-- 定义封装person和IdCard的resultMap -->
    <resultMap id="personIdCardMap" type="xyz.shi.entity.Person">
        <id property="id" column="id"/>
        <!--IdCard的id -->
        <result property="name" column="name"/>
        <!-- association配置一对一关系，property为Person中属性名，javaType为属性类型 -->
        <association property="idCard" javaType="xyz.shi.entity.IdCard">
            <!-- column="t_idCard_id 对应person表中的t_idCard_id-->
            <id property="id" column="t_idCard_id"/>
            <result property="cardNo" column="cardNo"/>
        </association>
    </resultMap>
    <!--配置查询所有-->
    <select id="findAll" resultMap="personIdCardMap">
        select p.name, p.id as pid, c.id as cid, c.cardNo from t_person p, t_idCard c where c.id = p.t_idCard_id
    </select>
<!--    通过id(唯一)获取用户-->
    <select id="queryOne" parameterType="int" resultMap="personIdCardMap">
        select p.name, p.id as pid, c.id as cid, c.cardNo from t_person p, t_idCard c where c.id = p.t_idCard_id and p.id=#{id}

    </select>
    <!-- 插入 -->
    <insert id="insert" parameterType="Person">
        insert into t_person (name,t_idCard_id) values(#{name},#{idCard.id})
    </insert>

    <update id="modify" parameterType="Person">
        update t_person set name=#{name},t_idCard_id=#{idCard.id} where id=#{id}
    </update>
    <!-- 根据 id 删除 -->
    <delete id="delete" parameterType="int">
        delete from t_person where id=#{id}
    </delete>
</mapper>

association配置一对一关系，其实就是把之前练习的学习Mybatis的内容移过来

  • dao
1
2
3
4
5
6
7
public interface PersonDao {
    Page<Person> findAll();
    Person queryOne(int id);
    int insert(Person person);
    int modify(Person person);
    int delete(int id);
}
  • service
1
2
3
4
5
6
7
public interface PersonService {
    Page<Person> findAll();
    Person queryOne(int id);
    int insert(Person person);
    int modify(Person person);
    int delete(int id);
}
  • 实现service
1
2
3
4
5
6
7
8
9
10
11
12
13

public class PersonServiceImpl implements PersonService {
    // 引用类型
    private PersonDao personDao;
    // 为了使用set注入来赋值,一定要加这个
    public void setPersonDao(PersonDao personDao) {
        this.personDao = personDao;
    }
    @Override
    public Page<Person> findAll() {
        return personDao.findAll();
   ....
}
  • 测试
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
public class PersonTest {
    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    // 其实就是调用的app..xml中的<bean id="userService" class="xyz.shi.service.Impl.UserServiceImpl">
    PersonService personService = (PersonService) context.getBean("personService");

    @Test
    public void TestFindAll() {
        //在查询之前，设置分页条件 显示第一页，展示3条数据
        Page<Object> page = PageHelper.startPage(1, 3);
        List<Person> personList = personService.findAll();
        // 设置分页导航数量5
        PageInfo<Person> pageInfo = new PageInfo<>(personList, 5);
        for (Person person:personList) {
            System.out.println("------每个用户的信息-------");
            System.out.println(person.getName());
            System.out.println(person.getIdCard().getCardNo());
        }
        System.out.println();
        ///xxx
        System.out.println("---------全面配置信息：--------");
        System.out.println("总数据量 :"+pageInfo.getTotal());
        System.out.println("每页的数量:"+pageInfo.getPageSize());
        System.out.println("当前页码:"+pageInfo.getPageNum());
        System.out.println("是否有上一页:"+pageInfo.isHasPreviousPage());
        System.out.println("上一页是:"+pageInfo.getPrePage());
        System.out.println("是否有下一页:"+pageInfo.isHasNextPage());
        System.out.println("下一页是:"+pageInfo.getNextPage());
        System.out.println("是否是第一页:"+pageInfo.isIsFirstPage());
        System.out.println("是否是最后一页:"+pageInfo.isIsLastPage());
        System.out.println("导航页的第一个页码是："+pageInfo.getNavigateFirstPage());
        System.out.println("导航页的最后一个页码是："+pageInfo.getNavigateLastPage());
        System.out.println("每页显示的页码个数："+pageInfo.getNavigatePages());
        System.out.println("页码数："+ Arrays.toString(pageInfo.getNavigatepageNums()));
    }
    @Test
    public void TestQueryOne() {
        Person person = personService.queryOne(16);
        System.out.println(person.getName());
        System.out.println(person.getIdCard().getCardNo());
    }
    @Test
    public void TestAddPerson() {
        Person person = new Person();
        person.setName("山大王");

        IdCard idCard = new IdCard();
        idCard.setCardNo("222");
        idCard.setId(14);

        person.setIdCard(idCard);

        personService.insert(person);
    }

    @Test
    public void TestModifyPerson() {
        Person person = new Person();
        person.setName("山大王234");
        person.setId(31);

        IdCard idCard = new IdCard();
        idCard.setId(17);

        person.setIdCard(idCard);
        personService.modify(person);
    }

    @Test
    public void TestDelete() {
        personService.delete(31);
    }
}

  • 一对多和多对多，配置基本一样唯一区别就是在mapper.xml使用association进行关联,他们的测试类分别为：GradeTest(一对多)，StudentTest(多对多)

  • 源代码

MybatisPlus

  • mybatis-plus在连表查询上是不行的，如果需要连表查询，那么我们就得乖乖的去写xml文件了
  • 推荐用一个插件，官网在这里
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class test {
    @Resource
    private UserMapper userMapper;

    @Test
    void testResultMap() {
        MPJLambdaWrapper<UserDO> wrapper = new MPJLambdaWrapper<>(User.class)
                .selectAll(UserDO.class)
                //对多查询
                .selectCollection(AddressDO.class, UesrDTO::getAddressList)
                //对一查询
                .selectAssociation(AddressDO.class, UesrDTO::getAddress)
                .leftJoin(AddressDO.class, AddressDO::getUserId, UserDO::getId);

        List<UserDTO> dtoList = userMapper.selectJoinList(UserDTO.class, wrapper);

        //关于对多分页查询
        //由于嵌套结果方式会导致结果集被折叠，因此分页查询的结果在折叠后总数会减少，所以无法保证分页结果数量正确。
    }
}