Spring boot 当表由多对多映射时，无法从数据库中获取数据

我无法从数据库中获取用户数据，我还想知道如何在多对多的情况下处理同一场景中的rest请求

我使用的是SpringBoot和SpringDataJPA。我的数据库代码如下：

CREATE TABLE `m3_group` (
  `GROUP_ID` bigint(11) NOT NULL AUTO_INCREMENT,
  `GROUP_NAME` varchar(30) DEFAULT NULL,
  `GROUP_CREATED_DATE` datetime DEFAULT NULL,
  `GROUP_ADMIN` varchar(14) DEFAULT NULL,
  PRIMARY KEY (`GROUP_ID`)
)

 ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

CREATE TABLE `m3_user` (
  `USER_ID` bigint(11) NOT NULL AUTO_INCREMENT,
  `USER_NAME` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`USER_ID`)
) ENGINE=InnoDB AUTO_INCREMENT=330 DEFAULT CHARSET=utf8;



CREATE TABLE `m3_user_group` (
  `GROUP_USER_ID` bigint(11) DEFAULT NULL,
  `GROUP_ID` bigint(11) DEFAULT NULL,
  KEY `FK1_GROUP_ID` (`GROUP_ID`),
  KEY `FK2_USER_ID` (`GROUP_USER_ID`),
  CONSTRAINT `FK1_GROUP_ID` FOREIGN KEY (`GROUP_ID`) REFERENCES `m3_group` (`GROUP_ID`),
  CONSTRAINT `FK2_USER_ID` FOREIGN KEY (`GROUP_USER_ID`) REFERENCES `m3_user` (`USER_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;  




@Entity
@Table(name = "M3_USER")
public class User implements Serializable 
{

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "USER_ID")
    private long userId;

    @NotBlank
    @Column(name = "USER_NAME")
    private String userName;

    //many-to-many
    @ManyToMany(mappedBy="listOfUsers",fetch=FetchType.EAGER)
    private List<Group> listOfGroup=new ArrayList<Group>();

    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 List<Group> getListOfGroup() {
        return listOfGroup;
    }

    public void setListOfGroup(List<Group> listOfGroup) {
        this.listOfGroup = listOfGroup;
    }

}


@Entity
@Table(name="M3_GROUP")  
public class Group implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="GROUP_ID")
    private long groupId;

    @Column(name="GROUP_NAME")
    private String groupName;

    @CreatedDate
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name="GROUP_CREATED_DATE")
    @JsonFormat(locale = "en-IN", shape = JsonFormat.Shape.STRING, pattern = 
    "yyyy-MM-dd HH:mm", timezone = "GMT+5:30")
    private Date groupCreatedDate;

    @Column(name="GROUP_ADMIN") 
    private String groupAdminMobileNumber;


    //many-to-many
    @ManyToMany(fetch=FetchType.EAGER)
    @JoinTable(name = "M3_USER_GROUP", joinColumns = @JoinColumn(name = 
    "GROUP_USER_ID") , inverseJoinColumns = @JoinColumn(name = "GROUP_ID") )
    private List<User> listOfUsers=new ArrayList<User>();

    public long getGroupId() {
        return groupId;
    }

    public void setGroupId(long groupId) {
        this.groupId = groupId;
    }

    public String getGroupName() {
        return groupName;
    }

    public void setGroupName(String groupName) {
        this.groupName = groupName;
    }

    public Date getGroupCreatedDate() {
        return groupCreatedDate;
    }

    public void setGroupCreatedDate(Date groupCreatedDate) {
        this.groupCreatedDate = groupCreatedDate;
    }

    public String getGroupAdminMobileNumber() {
        return groupAdminMobileNumber;
    }

    public void setGroupAdminMobileNumber(String groupAdminMobileNumber) {
        this.groupAdminMobileNumber = groupAdminMobileNumber;
    }

    public List<User> getListOfUsers() {
        return listOfUsers;
    }

    public void setListOfUsers(List<User> listOfUsers) {
        this.listOfUsers = listOfUsers;
    }
}




@Repository
public interface GroupRepository extends JpaRepository<Group, Long> {
    List<Group> findByGroupId(long groupid);

}


@RestController
public class GroupController 
{
    @Autowired
    GroupRepository groupRepository;

    @RequestMapping(value="/find/{groupId}",method=RequestMethod.POST)
    public ResponseEntity<List<Group>> find(@PathVariable String groupId)
    {
        long id=Long.parseLong(groupId);
        List<Group> group = groupRepository.findByGroupId(id);
        System.out.println(group.toString());
        return new ResponseEntity<List<Group>>(group,HttpStatus.OK);

    }
}

I have mapped the user and group table with many to many bidirectional and i am trying to fetch the data i.e users associated with the groupId but listOfUsers is showing empty.

My rest request is:
Http ://localhost:5000/find/1

And the response is:
[
{
"groupId": 1,
"groupName": "Om namo raghavendra",
"groupCreatedDate": "2017-05-17 12:48",
"groupAdminMobileNumber": "917676060664",
"listOfUsers":[
]
}
]

CREATE TABLE`m3_group`(
`组ID`bigint（11）非空自动增量，
`组名称'varchar（30）默认为空，
`组创建日期日期日期时间默认为空，
`GROUP_ADMIN`varchar（14）默认为空，
主键（`GROUP\u ID`）
)
ENGINE=InnoDB AUTO_INCREMENT=3默认字符集=utf8；
创建表“m3\U用户”(
`用户ID`bigint（11）非空自动增量，
`USER_NAME`varchar（50）默认为空，
主键（`USER\u ID`）
)ENGINE=InnoDB AUTO_INCREMENT=330默认字符集=utf8；
创建表“m3用户组”(
`组用户ID`bigint（11）默认为空，
`组ID`bigint（11）默认为空，
键'FK1_GROUP_ID'（'GROUP_ID'），
键“FK2用户ID”（“组用户ID”），
约束'FK1_GROUP_ID'外键（'GROUP_ID'）引用'm3_GROUP'（'GROUP_ID'），
约束'FK2\u USER\u ID'外键（'GROUP\u USER\u ID'）引用'm3\u USER'（'USER\u ID`）
)ENGINE=InnoDB默认字符集=utf8；
@实体
@表（name=“M3\U用户”）
公共类用户实现可序列化
{
@身份证
@GeneratedValue（策略=GenerationType.AUTO）
@列（name=“USER\u ID”）
私有长用户ID；
@不空白
@列（name=“USER\u name”）
私有字符串用户名；
//多对多
@ManyToMany（mappedBy=“listOfUsers”，fetch=FetchType.EAGER）
private List listOfGroup=new ArrayList（）；
公共长getUserId（）{
返回用户标识；
}
public void setUserId（长userId）{
this.userId=userId；
}
公共字符串getUserName（）{
返回用户名；
}
public void setUserName（字符串用户名）{
this.userName=用户名；
}
公共列表getListOfGroup（）{
返回组的列表；
}
public void setListOfGroup（组列表列表）{
this.listOfGroup=listOfGroup；
}
}
@实体
@表（name=“M3\U组”）
公共类组实现可序列化{
私有静态最终长serialVersionUID=1L；
@身份证
@GeneratedValue（策略=GenerationType.AUTO）
@列（name=“GROUP\u ID”）
私有长groupId；
@列（name=“GROUP\u name”）
私有字符串组名；
@创建数据
@时态（TemporalType.TIMESTAMP）
@列（name=“组创建日期”）
@JsonFormat（locale=“en-IN”，shape=JsonFormat.shape.STRING，pattern=
“yyyy-MM-dd HH:MM”，时区=“格林尼治时间+5:30”）
私有日期组创建日期；
@列（name=“GROUP\u ADMIN”）
私有字符串GroupAdminMobileEnumber；
//多对多
@ManyToMany（fetch=FetchType.EAGER）
@JoinTable（name=“M3\u USER\u GROUP”，joinColumns=@JoinColumn（name=
“组用户ID”），inverseJoinColumns=@JoinColumn（name=“组ID”））
private List listOfUsers=new ArrayList（）；
公共长getGroupId（）{
返回groupId；
}
public void setGroupId（长groupId）{
this.groupId=groupId；
}
公共字符串getGroupName（）{
返回groupName；
}
public void setGroupName（字符串groupName）{
this.groupName=groupName；
}
公共日期getGroupCreatedDate（）{
返回groupCreatedDate；
}
公共无效setGroupCreatedDate（日期groupCreatedDate）{
this.groupCreatedDate=groupCreatedDate；
}
公共字符串getGroupAdminMobileNumber（）{
返回GroupAdminMobileEnumber；
}
public void setGroupAdminMobileNumber（字符串groupAdminMobileNumber）{
this.groupAdminMobileNumber=groupAdminMobileNumber；
}
公共列表getListOfUsers（）{
返回用户列表；
}
public void setListoUsers（列表用户）{
this.listOfUsers=listOfUsers；
}
}
@存储库
公共接口GroupRepository扩展了JpaRepository{
列出findByGroupId（长groupid）；
}
@RestController
公共类组控制器
{
@自动连线
组存储库组存储库；
@RequestMapping（value=“/find/{groupId}”，method=RequestMethod.POST）
公共响应属性查找（@PathVariable String groupId）
{
long id=long.parseLong（groupId）；
List group=groupRepository.findByGroupId（id）；
System.out.println（group.toString（））；
返回新的响应状态（组，HttpStatus.OK）；
}
}
我已经用多对多双向映射了用户和组表，并且我正在尝试获取数据，即与groupId关联的用户，但是ListoUsers显示为空。
我的休息要求是：
Http://localhost:5000/find/1
答复是：
[
{
“groupId”：1，
“组名”：“Om namo raghavendra”，
“groupCreatedDate”：“2017-05-17 12:48”，
“groupAdminMobileNumber”：“917676060664”，
“用户列表”：[
]
}
]

listOfUsers

为空，因此我想使用groupId来访问用户