spring data jpa配置一对多，多对多关系映射

配置一对多关系映射

//配置一对多关系映射
    /**
     *     @OneToMany(targetEntity = LinkMan.class)
     *          targetEntity配置对方的字节码文件
     *     @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
     *          name配置外键名称，referencedColumnName配置外键引用主表的主键
     */
    @OneToMany(targetEntity = LinkMan.class)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
    private Set<LinkMan> linkMans=new HashSet<LinkMan>();

//配置多对一关系映射
    @ManyToOne(targetEntity = Customer.class)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
    private Customer customer;

编写测试类

import com.smx.dao.CustomerDao;
import com.smx.dao.LinkManDao;
import com.smx.domain.Customer;
import com.smx.domain.LinkMan;
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;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class OneToManyTest {
    @Autowired
    private CustomerDao customerDao;
    @Autowired
    private LinkManDao linkManDao;
    @Test
    @Transactional
    @Rollback(value = false)
    //测试保存操作
    public void addTest(){
        Customer customer=new Customer();
        customer.setCustName("百度");
        LinkMan linkMan=new LinkMan();
        linkMan.setLmkName("张三");

        customer.getLinkMans().add(linkMan);
        linkManDao.save(linkMan);
        customerDao.save(customer);


    }
}

多对多关系映射

用户类

package com.smx.domain;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "t_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "user_id")
    private Long userId;
    @Column(name = "user_name")
    private String userName;
    @Column(name = "user_age")
    private int age;
//配置多对多映射
    /**
     * @JoinTable配置中间表
     * name中间表名称
     * joinColumns自身对象外键
     * inverseJoinColumns对方外键
     */
    @ManyToMany(targetEntity = Role.class,cascade = {CascadeType.MERGE,CascadeType.PERSIST})
    @JoinTable(
            name = "t_user_role",
            joinColumns = {@JoinColumn(name = "p_user_id",referencedColumnName = "user_id")},
            inverseJoinColumns = {@JoinColumn(name = "p_role_id",referencedColumnName = "role_id")}
    )
   //@ManyToMany(mappedBy = "roles")
    private Set<Role> users=new HashSet<Role>();

    public Set<Role> getUsers() {
        return users;
    }

    public void setUsers(Set<Role> users) {
        this.users = users;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }
}

角色类

package com.smx.domain;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "t_role")
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "role_id")
    private Long roleId;
    @Column(name = "role_name")
    private String roleName;

    //配置多对多映射
   /* @ManyToMany(targetEntity = User.class)
    @JoinTable(
            name = "t_user_role",
            joinColumns = {@JoinColumn(name = "p_role_id",referencedColumnName = "role_id")},
            inverseJoinColumns = {@JoinColumn(name = "p_user_id",referencedColumnName = "user_id")}
    )*/
   //放弃维护
    @ManyToMany(mappedBy = "users",cascade = {CascadeType.MERGE,CascadeType.PERSIST})
    private Set<User> roles=new HashSet<User>();

    public Set<User> getRoles() {
        return roles;
    }

    public void setRoles(Set<User> roles) {
        this.roles = roles;
    }

    public Long getRoleId() {
        return roleId;
    }

    public void setRoleId(Long roleId) {
        this.roleId = roleId;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                '}';
    }
}

UserDao和RoleDao实现spring data jpa 接口规范即可

public interface UserDao extends JpaRepository<User,Long>, JpaSpecificationExecutor<User> {
}

测试类

import com.smx.dao.RoleDao;
import com.smx.dao.UserDao;
import com.smx.domain.Role;
import com.smx.domain.User;
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;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TestManyToMany {
    @Autowired
    private UserDao userDao;
    @Autowired
    private RoleDao roleDao;
    @Test
    @Transactional
    @Rollback(false)
    public void testMTM(){
        User user = new User();
        user.setUserName("张三");

        Role role = new Role();
        role.setRoleName("学生");
        //配置用户到角色的关系，可以对中间表数据进行维护
        user.getUsers().add(role);
        //配置角色到用户的关系，可以对中间表数据进行维护   但是两个都存在必须方法一个外键维护
        role.getRoles().add(user);

        userDao.save(user);
    }

}

spring data jpa 复杂查询

需要在接口里面写方法

package com.smx.dao;

import com.smx.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import java.util.List;

/**
 * 符合spring data jpa接口规范
 *      JpaRepository<操作的实体类类型，主键属性类型>
 *          封装了基本的CRUD
 *      JpaSpecificationExecutor<操作的实体类类型>
 *          封装了复杂类型的查询（分页）
 */
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    /**
     * 根据名称查询
     */
    @Query(value = "from Customer where custName= ? ")
    public Customer findByName(String custName);
    /**
     * 修改方法
     * @Query是查询操作
     * @Modifying更新操作
     */
    @Query(value = "update Customer set custName= ? where id=?")
    @Modifying
    void update(String custName,Long custId);
    /**
     * 使用sql进行查询
     * nativeQuery = true使用sql进行查询
     * nativeQuery = false使用jpql进行查询
     */
    @Query(value = "select * from t_customer ",nativeQuery = true)
    public List<Customer> findSql();

    @Query(value = "select * from t_customer where cust_industry like ?",nativeQuery = true)
    List<Customer> findCustomersByCustIndustry(String industry);
    /**
     * 命名规则定义方法名进行查询
     */
    Customer findByCustName(String custName);
    /**
     * 命名规则定义方法名进行模糊查询
     */
    Customer findByCustNameLike(String custName);
    /**
     * 使用custName模糊查询和所属行业精确查询
     */
    List<Customer> findByCustNameLikeAndCustIndustry(String custName,String industry);
}

级联操作

 @OneToMany(mappedBy = "customer",cascade = {CascadeType.MERGE})

MERGE：更新
PERSIST:保存
REMOVE:删除