GraphQL在Springboot+mybatis中的结合

1.      使用步骤

1)        首先创建当前这个controller的查询器我创建了queue的查询器QueueQuery.java

2)        在查询器中注入service，这个查询器就是分解了请求过来的方法名

3)        在controller的某一个方法中调用，与别的url地址方法不冲突。可以指定某一个url使用这个graphql查询语句，我的controller是QueueGraphQLController

2.      注解的使用@GraphQLQuery(name="name")，@GraphQLMutation(name= "createQueue")

a)        在类中get方法上使用时，代表查询时候的别名，可以不爆露我们的字段。默认使用javabean的

b)        在查询器的方法名上使用，代表查询的方法也是别名

3.      注解@GraphQLArgument(name = "name") String name

a)        在查询语句中使用时候，代表闯入参数的名称对应后台的名称，不可省略

。

以上步骤请结合java的后台进行验证

1.maven依赖

<dependency>
		    <groupId>com.graphql-java</groupId>
		    <artifactId>graphql-java</artifactId>
		    <version>7.0</version>
		</dependency>
		<dependency>
		    <groupId>io.leangen.graphql</groupId>
		    <artifactId>spqr</artifactId>
		    <version>0.9.6</version>

</dependency>

我的controller

package com.ewe.workorder.controller;

/**
 * 用户的核心业务层
 */

import com.ewe.workorder.graphquery.EchartQuery;
import com.ewe.workorder.graphquery.WorkorderQuery;

import graphql.*;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.ewe.core.exception.CustomException;
import com.ewe.workorder.graphquery.QueueQuery;
import com.ewe.workorder.graphquery.utils.MyGraphqlError;
import com.ewe.workorder.graphquery.utils.MyGraphqlErrorData;

import java.lang.reflect.InvocationTargetException;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import graphql.language.SourceLocation;
import graphql.schema.GraphQLSchema;
import io.leangen.graphql.GraphQLSchemaGenerator;
import io.leangen.graphql.metadata.strategy.query.AnnotatedResolverBuilder;
import io.leangen.graphql.metadata.strategy.query.PublicResolverBuilder;
import io.leangen.graphql.metadata.strategy.value.jackson.JacksonValueMapperFactory;

@RestController
public class GraphQLController  {
	private final GraphQL graphQlFromAnnotated;
	private static final Logger LOGGER = LoggerFactory.getLogger(GraphQLController.class);

	@Autowired
	/**
	 * 这是注册器
	 * @param orderQuery
	 */
    public GraphQLController(QueueQuery orderQuery,WorkorderQuery workorderQuery,EchartQuery echartQuery) {
		 //Schema generated from query classes
        GraphQLSchema schemaFromAnnotated = new GraphQLSchemaGenerator()
                .withResolverBuilders(
                        //Resolve by annotations
                        new AnnotatedResolverBuilder(),
                        //Resolve public methods inside root package
                        new PublicResolverBuilder("com.ewe.workorder"))
                .withOperationsFromSingleton(orderQuery)
                .withOperationsFromSingleton(workorderQuery)
                .withOperationsFromSingleton(echartQuery)
                .withValueMapperFactory(new JacksonValueMapperFactory())
                .generate();
        graphQlFromAnnotated = GraphQL.newGraphQL(schemaFromAnnotated).build();
        LOGGER.info("Generated GraphQL schema using SPQR");
        }

	 	@SuppressWarnings("deprecation")
		@PostMapping(value = "/graphql", consumes = MediaType.APPLICATION_JSON_UTF8_VALUE, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
	    @ResponseBody
	    public Object indexFromAnnotated(@RequestBody Map<String, Object> request) {
	 		LOGGER.info("graphql进入");
			String query=(String) request.get("query");
			if(query!=null){
				
			}
			else if(query==null){
				 query=(String) request.get("mutation");
			}
			
			if(query==null){
				throw new CustomException("The option name can't be null", HttpStatus.INTERNAL_SERVER_ERROR);
			}
			query=query.replaceAll("\'", "\"");
			LOGGER.info(query);
			
			String operationName=(String) request.get("operationName");
			LOGGER.info(operationName);
			long start=(new Date()).getTime();
			ExecutionInput executionInput=new ExecutionInput(query, operationName,null,null, (Map<String,Object>)request.get("variables"));
	        ExecutionResult executionResult = graphQlFromAnnotated.execute(executionInput);
			/**
			 * 使用自己定义的错误返回
			 */
	        if (!executionResult.getErrors().isEmpty()) {
	        	//自定义的error
	         	MyGraphqlErrorData data=new MyGraphqlErrorData();
	         	MyGraphqlError error=new MyGraphqlError();
	         	
	        	error.setErrors(sanitize(executionResult).getErrors());
	        	data.setData(error);
	        	LOGGER.info(data.toString()+"");
	        	return data;
	        }

        long end=(new Date()).getTime();
		LOGGER.info("查询耗时==>"+(end-start+"ms"));
        return executionResult;
	}
 	 /**
 	  * 返回我们想要的message中的信息
 	  * @param executionResult
 	  * @return
 	  */
    private ExecutionResult sanitize(ExecutionResult executionResult) {
        return new ExecutionResultImpl(executionResult.getErrors().stream()
                .peek(err -> LOGGER.error(err.getMessage()))
                .map(this::sanitize)
                .collect(Collectors.toList()));
    }
    /**
     * 对错误进行处理
     * @param error
     * @return
     */
    private GraphQLError sanitize(GraphQLError error) {
        if (error instanceof ExceptionWhileDataFetching) {
            return new GraphQLError() {
                @Override
                public String getMessage() {
                    Throwable cause = ((ExceptionWhileDataFetching) error).getException().getCause();
                    return cause instanceof InvocationTargetException ? ((InvocationTargetException) cause).getTargetException().getMessage() : cause.getMessage();
                }

                @Override
                public List<SourceLocation> getLocations() {
                    return error.getLocations();
                }

                @Override
                public ErrorType getErrorType() {
                    return error.getErrorType();
                }
            };
        }
        return error;
    } 	
}

2.增加一个查询器

package com.ewe.workorder.GraphQLQuery;

import io.leangen.graphql.annotations.GraphQLArgument;
import io.leangen.graphql.annotations.GraphQLMutation;
import io.leangen.graphql.annotations.GraphQLQuery;

import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ewe.workorder.controller.QueueGraphQLController;
import com.ewe.workorder.model.Queue;
import com.ewe.workorder.model.Users;
import com.ewe.workorder.service.IQueueService;
@Component
public class QueueQuery{
	private static final Logger LOGGER = LoggerFactory.getLogger(QueueGraphQLController.class);

	@Autowired
    private IQueueService queueService;

    /**
     * 方法名@GraphQLQuery 去别名的意思
     * @return
     */
	@GraphQLQuery(name = "queues")
    public List<Queue> queues() {
        return queueService.getList();
    }
	/*
	 * 根据queueid查询数据
	 */
	@GraphQLQuery(name = "queuesById")
    public Queue queuesById(@GraphQLArgument(name = "id") Integer queueId) {
		Queue queue=queueService.selectByqueueId(queueId);
		if(queue!=null&&queue.getUsers().size()>0){
			LOGGER.info("size=>>{}",queue.getUsers().size());
			//根据用户名查询信息查询信息
			List<Users> users=new ArrayList<Users>();
			for(Users user :queue.getUsers()){
				users.add(queueService.selectByUserName(user.getUsername()));
			}
			queue.setUsers(users);
		}
		
		
        return queue;
    }
	/**
	 * 根据用户名查询
	 * @param userName
	 * @return
	 */
	@GraphQLQuery(name = "userQueue")
    public Users queuesByuserName(@GraphQLArgument(name = "name")String userName) {
		Users user=queueService.selectByUserName(userName);
		if(user!=null&&user.getQueues().size()>=0)
		{
			LOGGER.info("queues size=>>{}",user.getQueues().size());
			LOGGER.info("person size=>>{}",user.getQueues().get(0).getUsers().size());
			//根据id查询信息
			List<Queue> queues=new ArrayList<Queue>();
			for(Queue queue :user.getQueues()){
				queues.add(queueService.selectByqueueId(queue.getId()));
			}
			user.setQueues(queues);
		}
		
        return user;
    }
	/**
	 * 添加数据
	 * @param queue
	 * @return
	 */
	@GraphQLMutation(name = "createQueue")
    public Queue createQueue(@GraphQLArgument(name = "name") String name,@GraphQLArgument(name = "description")String description){
		Queue queue=new Queue();
		queue.setName(name);
		queue.setDescription(description);
		LOGGER.info(queue.getName());
        return queueService.addqueue(queue);
    } 
/*	@GraphQLMutation(name = "createQueue")
    public Queue createQueue(@GraphQLArgument(name = "Queue")Queue queue){
    	LOGGER.info(queue.getName());
    	return queueService.addqueue(queue);
    } */
/*	@GraphQLQuery(name = "test")
    public List<Queue> test(@GraphQLArgument(name = "Queue") Queue queue) {
		LOGGER.info(queue.getName());
        return queueService.getList();
    }*/
}

我的Queuemodel

package com.ewe.workorder.model;

import java.util.List;

import com.ewe.workorder.model.Users;

import io.leangen.graphql.annotations.GraphQLQuery;

public class Queue {
    private Integer id;

    
    private String name;

    private String description;

    List<Users> users;
    
    public List<Users> getUsers() {
		return users;
	}

	public void setUsers(List<Users> users) {
		this.users = users;
	}
	 @GraphQLQuery(name="id")
	public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
    @GraphQLQuery(name="name")
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description == null ? null : description.trim();
    }
}

最后进行测试语句输入：

{
	"query":"{userQueue(name:'admin'){username,email,queues{name,users{username}}}}"
		
}

结果

{
    "userQueue": {
        "username": "admin",
        "email": "t3wq",
        "queues": [
            {
                "name": "test1",
                "users": [
                    {
                        "username": "124"
                    },
                    {
                        "username": "123"
                    }
                ]
            },
            {
                "name": "213",
                "users": [
                    {
                        "username": "123"
                    }
                ]
            },
            {
                "name": "",
                "users": [
                    {
                        "username": ""
                    }
                ]
            }
        ]
    }
}