spring jpa query practice

Tested entity mapping plus queries..

Given table relationships like this

1
tb_member -< tb_member_inter >- tb_inter

Query conditions

When fetching a Member.. also fetch the member’s images… and the list of inters
Inter details live in tb_inter (join when fetching..)

Quick notes on the classes below

MemberInter has two PKs, so you need to make a separate class and specify @IdClass as shown
@Expose is a Gson option for choosing which fields to render. Nothing to do with jpa.
MemberInter.class confused me a lot. (@ManyToOne)
- You also need.. @JoinColumn.
- optional=true makes the join an outer join. (false is inner join)

FetchType

FetchType.EAGER -> fetch immediately and fill the data
FetchType.LAZY -> query the DB when needed

Field names must use CamelCase. Otherwise method named queries get painful later.

Member.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
@Entity @Table(name = "tb_member")
public class Member {
    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer member_seq;

    @Expose
    @OneToMany(
            targetEntity = Image.class
            , cascade = CascadeType.ALL
            , fetch = FetchType.EAGER
            , mappedBy = "member_seq")
    private List<image> imageList;

    @Expose
    @OneToMany(
            targetEntity = MemberInter.class
            , cascade = CascadeType.ALL
            , fetch = FetchType.EAGER
            , mappedBy = "member_seq")
    private List<Memberinter> memberInterList;
}

MemberRepository.java

1
2
3
public interface MemberRepository extends JpaRepository<Member, Integer> {

}

Image.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
@Entity
@Table(name = "tb_image")
public class Image {
    @Id
    @GeneratedValue
    private Integer image_seq;
    @Column
    private Integer member_seq;
    @Column @Expose
    private String file_name;
}

Inter.java

1
2
3
4
5
6
7
@Entity @Table(name="tb_inter") @Embeddable
public class Inter {
    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer inter_seq;
    @Column @Expose
    private String inter_name_ko;
}

MemberInter.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
@Entity @Table(name="tb_member_inter") @IdClass(MemberInterPk.class)
public class MemberInter {
    @Id @Column
    private Integer member_seq;

    @Id @Column(insertable = false, updatable = false)
    private Integer inter_seq;

    @ManyToOne(
            targetEntity = Inter.class
            ,cascade = CascadeType.ALL
            ,fetch = FetchType.EAGER
            ,optional = false
    )
    @JoinColumn(name = "inter_seq")
    @Expose
    private Inter inter;
}

MemberInterPk.java

1
2
3
4
public class MemberInterPk implements Serializable {
    private Integer member_seq;
    private Integer inter_seq;
}

Test code…

TestServiceTest.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({
        "classpath:servlet-context.xml",
        "classpath:config/context-datasource.xml"
})
public class TestServiceTest {
    private static final Logger logger = LoggerFactory.getLogger(TestServiceTest.class);

    @Autowired
    private Gson gson;

    @Autowired
    private MemberRepository memberRepository;

    @Test
    public void testGetMemberList() throws Exception {
        logger.info("------------ jpa test starting.... ------------------------");

        List&lt;member> list = memberRepository.findAll();
        logger.info("memberList={}", gson.toJson(list));

        logger.info("------------ jpa test ended....    ------------------------");
    }
}