Spring Data jpa 多对多关系使用

最新推荐文章于 2024-09-02 16:54:09 发布

无法长大.

最新推荐文章于 2024-09-02 16:54:09 发布

阅读量234

点赞数

分类专栏：后端文章标签： jpa

本文链接：https://blog.csdn.net/weixin_45854365/article/details/105941071

版权

后端专栏收录该内容

4 篇文章 0 订阅

订阅专栏

user实体类

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import javax.persistence.*;
import java.util.Date;
import java.util.List;

//Entity注解和数据表有映射关系
//如果数据库表和实体类不一致，需要table注解，指定表名
@Setter
@Getter
@ToString
@Entity
@Table(name = "t_user",catalog = "1708d",schema = "1708d")
@ApiModel("用户的实体类")
public class UserEntity {
    /** 主键的生成策略： IDENTITY、AUTO **/
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    //没有被注解的属性，在建表也会生成对应的字段。
    @ApiModelProperty("用户登录名称")
    private String username;

    @Column(columnDefinition = "varchar(64) DEFAULT NULL COMMENT '密码'")
    private String password;
    //字段精度设置：precision长度，scale小数的位数
    @Column(precision = 10,scale = 2,columnDefinition = "double(10,2) DEFAULT NULL COMMENT '积分'")
    private Double score;

    private Integer sex;

    private Integer classesId;
    //非数据的映射字段，加Transient注解
    @Transient
    private String classesName;

    @Transient
    private String orderNo;

    //枚举
    @JsonFormat(shape = JsonFormat.Shape.NUMBER)
    @Enumerated(EnumType.ORDINAL)
    private DeleteEnum isDelete;
    //大字段lob
    @Lob
    private String content;

    //按java命名规范，在表里生成create_time字段
    private Date createTime;
    //指定时间的精度,默认是datetime
    @Temporal(TemporalType.TIMESTAMP)
    private Date updateTime;

    //忽略OrderEntity的user属性
    /*@JsonIgnoreProperties("user")
    @OneToMany(mappedBy = "userId")
    private List<OrderEntity> orderList;*/

    @JsonIgnoreProperties("user")
    @OneToMany
    @JoinColumn(name = "userId",insertable = false,updatable = false)
    private List<OrderEntity> orderList;

    //多对多关系
    //JoinTable name是关系表的表名 joinColumns是主表在关系表对应的列，inverseJoinColumns从表对应的列
    @JsonIgnoreProperties("userList")
    @ManyToMany
    @JoinTable(name = "t_user_role_relation",joinColumns = @JoinColumn(name = "user_id"),
            inverseJoinColumns = @JoinColumn(name = "role_id"))
    private List<RoleEntity> roleList;

}

role实体类

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.hibernate.annotations.DynamicUpdate;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.*;
import java.util.Date;
import java.util.List;

//Entity注解和数据表有映射关系
//如果数据库表和实体类不一致，需要table注解，指定表名
@Setter
@Getter
@ToString
@Entity
@EntityListeners(AuditingEntityListener.class)
@Table(name = "t_role",catalog = "1708d",schema = "1708d")
public class RoleEntity {
    /** 主键的生成策略： IDENTITY、AUTO **/
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    //角色名称
    private String name;

    @CreatedDate
    @Temporal(TemporalType.TIMESTAMP)
    private Date createTime;

    @LastModifiedDate
    @Temporal(TemporalType.TIMESTAMP)
    private Date updateTime;

    @CreatedBy
    private Integer createBy;

    @LastModifiedBy
    private Integer updateBy;

    //多对多关系
    //JoinTable name是关系表的表名 joinColumns是主表在关系表对应的列，inverseJoinColumns从表对应的列
    @JsonIgnoreProperties("roleList")
    @ManyToMany
    @JoinTable(name = "t_user_role_relation",joinColumns = @JoinColumn(name = "role_id"),
            inverseJoinColumns = @JoinColumn(name = "user_id"))
    private List<UserEntity> userList;
}

中间表

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import javax.persistence.*;

//Entity注解和数据表有映射关系
//如果数据库表和实体类不一致，需要table注解，指定表名
@Setter
@Getter
@ToString
@Entity
@Table(name = "t_user_role_relation",catalog = "1708d",schema = "1708d")
public class UserRoleRelationEntity {
    /** 主键的生成策略： IDENTITY、AUTO **/
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    //用户Id
    private Integer userId;
    //角色Id
    private Integer roleId;
}

枚举类

import org.springframework.context.annotation.Primary;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 软删除的枚举类
 */
public enum DeleteEnum {
    YES(1),NO(0);

    private Integer value;

    DeleteEnum(Integer value) {
        this.value = value;
    }

    /**
     * 封装枚举类成List，Controller调用该静态方法，返回给前端。
     * @return
     */
    public static List<Map<String,Object>> getDeleteList(){
        List<Map<String,Object>> delTypeList = new ArrayList<>();
        DeleteEnum[] values = DeleteEnum.values();
        for (DeleteEnum deleteEnum : values){
            Map<String,Object> delMap = new HashMap<>();
            delMap.put("id",deleteEnum.ordinal());
            delMap.put("name",deleteEnum.name());
            delTypeList.add(delMap);
        }
        return delTypeList;
    }


}

dao

import org.hibernate.sql.Update;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
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 org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

public interface UserRepository extends JpaRepository<UserEntity,Integer>, JpaSpecificationExecutor<UserEntity> {
    //自定义方法，是以findBy开始的方法
    List<UserEntity> findByUsername(String username);
    //模糊查询
    List<UserEntity> findByUsernameLike(String username);
    //排序
    List<UserEntity> findByUsernameLikeOrderByIdDesc(String username);
    //分页，分页的时候可以指定排序条件
    Page<UserEntity> findByUsername(String username, Pageable pageable);
    //排序
    List<UserEntity> findByUsername(String username, Sort sort);
    //自定义删除方法
    @Transactional
    int deleteByUsername(String username);
    @Transactional
    int deleteByUsernameAndSex(String username,Integer sex);
    @Transactional
    int deleteBySexIsNull();

    //注解方法
    //?1,?2是方法的参数顺序
    @Query("select u from UserEntity u where u.username=?1 and u.password=?2")
    List<UserEntity> queryByUsernameAndPassword(String username,String password);
    //原生SQL
    @Query(value = "select * from t_user where username=?1 and password=?2",nativeQuery = true)
    List<UserEntity> selectByUsernameAndPassword(String username,String password);
    //Param参数注解
    @Query("select u from UserEntity u where u.username=:uname and u.password=:pwd")
    List<UserEntity> queryByUsernameAndPasswordByParam(@Param("uname") String username,@Param("pwd") String password);
    //Param参数注解,分页排序
    @Query("select u from UserEntity u where u.username=:uname and u.password=:pwd")
    List<UserEntity> queryByUsernameAndPasswordByParam(@Param("uname") String username,@Param("pwd") String password,Pageable pageable);
    //通过Query注解，更新表字段
    @Modifying
    @Transactional
    @Query("update UserEntity u set u.password=:pwd where id=:id")
    int updatePsswordById(@Param("id") Integer id,@Param("pwd") String pwd);

}

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;

public interface RoleRepository extends JpaRepository<RoleEntity,Integer> {
    @Modifying
    @Transactional
    @Query("update RoleEntity r set r.name=:name where r.id=:id")
    int updateNameById(@Param("id") Integer id, @Param("name") String name);
}

service

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.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import javax.persistence.criteria.*;
import java.util.ArrayList;
import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public Page<UserEntity> getPageInfo(UserEntity userEntity,Integer pageNum,Integer pageSize) {
        //分页
        Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
        //构建Specification
        Specification<UserEntity> specification = new Specification() {
            @Override
            public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder cb) {
                //保存多个查询条件
                List<Predicate> predicates = new ArrayList<>();
                //查询字段不为空的时候，添加条件
                if (userEntity.getUsername() != null) {
                    //构建条件
                    Predicate predicate = cb.like(root.get("username"), "%".concat(userEntity.getUsername()).concat("%"));
                    //添加到predicates
                    predicates.add(predicate);
                }
                if(userEntity.getOrderNo()!=null){
                   //user链接查询order表，join是orderList，按订单编号模糊查询
                   Predicate predicate = cb.like(root.join("orderList").get("orderNo"),"%".concat(userEntity.getOrderNo().concat("%")));
                   predicates.add(predicate);
                }
                //返回的接口
                return cb.and(predicates.toArray(new Predicate[predicates.size()]));
            }
        };
        return  userRepository.findAll(specification,pageable);
    }
}

controller

  @Autowired
    private UserService userService;

    @Autowired
    private OrderService orderService;



    /**
     * 分页接口
     */
    @ApiOperation(value = "用户分页列表接口",notes = "当前页和分页小默认值：1,10")
    @GetMapping("user")
    public Page<UserEntity> getPageInfo(UserEntity userEntity,@RequestParam("pageNum") Integer pageNum,
                                        @RequestParam("pageSize") Integer pageSize){

        return  userService.getPageInfo(userEntity,pageNum,pageSize);
    }