graphql-java的CRUD及关联查询

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
@Entity
@Data
public class Fans {
/**
* 主键
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
/**
* 创建时间
*/
private LocalDateTime createdTime;
/**
* 更新时间
*/
private LocalDateTime updatedTime;
/**
* firstName
*/
private String firstName;
/**
* lastName
*/
private String lastName;
/**
* authorId
*/
@Column(name = "author_id")
private Long authorId;
}

1
2
3
4
	@OneToMany(targetEntity = Fans.class)
@JoinColumn(name = "author_id",referencedColumnName = "id")
private List<Fans> fans;

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
@Component
public class FansFetcher {
private final FansService fansService;
public FansFetcher(FansService fansService) {
this.fansService = fansService;
}
public DataFetcher<List<Fans>> getAllFans() {
return dataFetchingEnvironment -> fansService.getAllFans();
}
public DataFetcher<List<Fans>> getAuthorFans() {
return dataFetchingEnvironment -> fansService.getAuthorFans(dataFetchingEnvironment.getArgument("authorId"));
}
public DataFetcher<Fans> fansById() {
return dataFetchingEnvironment -> fansService.fansById(dataFetchingEnvironment.getArgument("id"));
}
public DataFetcher<Fans> saveFans() {
return dataFetchingEnvironment ->
fansService.saveFans(this.mapLinkedMapToFans(dataFetchingEnvironment.getArgument("fans")));
}
public DataFetcher<Boolean> deleteFans() {
return dataFetchingEnvironment -> {
fansService.deleteFansById(dataFetchingEnvironment.getArgument("id"));
return true;
};
}
private Fans mapLinkedMapToFans(Map<String, String> mapping) {
Fans fans = new Fans();
fans.setCreatedTime(LocalDateTime.now());
fans.setUpdatedTime(LocalDateTime.now());
fans.setLastName(mapping.get("lastName"));
fans.setFirstName(mapping.get("firstName"));
fans.setAuthorId(Long.parseLong(mapping.get("authorId")));
return fans;
}
}

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
@Component
public class AuthorSchema {
private final AuthorFetcher authorFetcher;
private final FansFetcher fansFetcher;
private GraphQL graphQL;
public AuthorSchema(AuthorFetcher authorFetcher, FansFetcher fansFetcher) {
this.authorFetcher = authorFetcher;
this.fansFetcher = fansFetcher;
}
@Bean
public GraphQL genGraphQL() {
return graphQL;
}
@PostConstruct
public void init() throws FileNotFoundException {
GraphQLSchema graphQLSchema = this.graphQLSchema(ResourceUtils.getFile("classpath:graphql/author.graphqls"));
graphQL = GraphQL.newGraphQL(graphQLSchema).build();
}
private GraphQLSchema graphQLSchema(File sdl) {
TypeDefinitionRegistry typeDefinitionRegistry = new SchemaParser().parse(sdl);
RuntimeWiring runtimeWiring = this.buildRunTimeWiring();
SchemaGenerator schemaGenerator = new SchemaGenerator();
return schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);
}
private RuntimeWiring buildRunTimeWiring() {
return RuntimeWiring.newRuntimeWiring()
.type("Query",
builder -> builder.dataFetcher("allAuthor", authorFetcher.getAllAuthor())
.dataFetcher("authorById", authorFetcher.authorById())
.dataFetcher("authorFans", fansFetcher.getAuthorFans())
.dataFetcher("fansById", fansFetcher.fansById())
)
.type("Mutation",
builder -> builder.dataFetcher("saveAuthor", authorFetcher.saveAuthor())
.dataFetcher("deleteAuthorById", authorFetcher.deleteAuthor())
.dataFetcher("saveFans", fansFetcher.saveFans())
.dataFetcher("deleteFansById", fansFetcher.deleteFans())
)
.build();
}
}

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
schema {
query: Query
mutation: Mutation
}
type Query{
# 查询所有作者
allAuthor:[Author!]
# 根据Id获取作者
authorById(id:Long):Author!
# 查询作者的粉丝
authorFans(id:Long):[Fans!]
# 根据Id获取粉丝
fansById(id:Long):Fans!
}
type Mutation{
# 保存作者
saveAuthor(author:AuthorInput):Author
# 根据作者id删除作者
deleteAuthorById(id:Long):Boolean
# 保存粉丝
saveFans(fans:FansInput):Fans
# 根据作者id删除粉丝
deleteFansById(id:Long):Boolean
}
input AuthorInput{
id:ID
firstName:String
lastName:String
}
scalar Long
#作者对象
type Author{
id:ID
firstName:String
lastName:String
fans:[Fans!]
}
input FansInput{
id:ID
firstName:String
lastName:String
authorId:Long
}
#粉丝对象
type Fans{
id:ID
firstName:String
lastName:String
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
authorList: allAuthor
{
...comparisonFields
}
}
fragment comparisonFields on Author {
id
firstName
lastName
fans {
fansId:id
fansFirstName:firstName
}
}

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
{
"data": {
"authorList": [
{
"id": "1",
"firstName": "希望",
"lastName": "测试",
"fans": [
{
"fansId": "1",
"fansFirstName": "fans"
},
{
"fansId": "2",
"fansFirstName": "fans"
}
]
},
{
"id": "2",
"firstName": "A",
"lastName": "B",
"fans": [
{
"fansId": "3",
"fansFirstName": "fans"
}
]
}
]
}
}