http 参数类型 GraphQL及后台java spring boot支持

于 2025-01-09 16:23:37 发布
阅读量143 收藏
点赞数 2
分类专栏： web java 文章标签： java http graphql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/nbspzs/article/details/145036933
版权 
HTTP 参数类型 和 GraphQL 是两种不同的数据传输方式，分别用于传统 RESTful API 和 GraphQL API。以下是它们的对比和详细介绍：

 1. HTTP 参数类型
在传统的 RESTful API 中，HTTP 请求通常通过以下几种方式传递参数：

 1.1 查询参数 (Query Parameters)
 位置：URL 中 ? 后。
 示例：
  
  GET /users?name=John&age=30
  
 特点：
   适合简单、非敏感数据。
   数据暴露在 URL 中，不适合敏感信息。

 1.2 路径参数 (Path Parameters)
 位置：URL 路径中。
 示例：
  
  GET /users/123
  
 特点：
   用于标识资源。
   通常用于获取特定资源。

 1.3 请求体 (Request Body)
 位置：HTTP 请求体中。
 示例：
  
  POST /users
  ContentType: application/json

  {
    "name": "John",
    "age": 30
  }
  
 特点：
   适合复杂数据，尤其是 POST 和 PUT 请求。
   支持多种格式（如 JSON、XML）。

 1.4 请求头 (Headers)
 位置：HTTP 请求头中。
 示例：
  
  GET /users
  Authorization: Bearer <token>
  
 特点：
   用于传递元数据（如认证信息）。
   适合传递不频繁变化的数据。

 2. GraphQL
GraphQL 是一种用于 API 的查询语言，允许客户端精确指定所需数据，减少不必要的数据传输。

 2.1 查询 (Query)
 位置：请求体中。
 示例：
  graphql
  query {
    user(id: 123) {
      name
      age
    }
  }
  
 特点：
   客户端指定所需字段。
   减少不必要的数据传输。

 2.2 变量 (Variables)
 位置：请求体中，与查询分离。
 示例：
  graphql
  query GetUser($userId: ID!) {
    user(id: $userId) {
      name
      age
    }
  }

  {
    "userId": 123
  }
  
 特点：
   提高查询复用性。
   避免在查询字符串中硬编码参数。

 2.3 变更 (Mutation)
 位置：请求体中。
 示例：
  graphql
  mutation {
    createUser(name: "John", age: 30) {
      id
      name
      age
    }
  }
  
 特点：
   用于创建、更新或删除数据。
   类似于 RESTful API 的 POST、PUT、DELETE 操作。

 2.4 订阅 (Subscription)
 位置：请求体中。
 示例：
  graphql
  subscription {
    userAdded {
      id
      name
      age
    }
  }
  
 特点：
   用于实时数据更新。
   通常通过 WebSocket 实现。

 3. 对比
| 特性                | HTTP 参数类型                  | GraphQL                      |
||||
| 数据传输方式     | URL、请求体、请求头            | 请求体（JSON 格式）          |
| 灵活性           | 有限，需遵循 RESTful 规范      | 高，客户端指定所需字段       |
| 性能优化         | 可能返回冗余数据               | 精确获取所需数据，减少冗余   |
| 实时数据         | 不支持                        | 支持（通过 Subscription）    |
| 学习曲线         | 较低                          | 较高                         |

 4. 总结
 HTTP 参数类型：适合简单、标准的 RESTful API，易于实现和理解。
 GraphQL：适合复杂、灵活的 API 需求，客户端可以精确控制数据获取，减少冗余数据传输。

 建议
 选择依据：根据项目需求选择合适的技术，简单场景用 RESTful API，复杂场景用 GraphQL。
 性能优化：GraphQL 需注意查询复杂度，避免性能问题。
 工具支持：GraphQL 有丰富的工具和库（如 Apollo、Relay），可提升开发效率。
以下是一个完整的 GraphQL 示例，包括 Schema 定义、查询、变更 和 订阅，并展示如何使用 GraphQL API。



 1. GraphQL Schema 定义
Schema 定义了 API 的数据结构和操作（查询、变更、订阅）。

graphql
type User {
  id: ID!
  name: String!
  age: Int!
  email: String!
}

type Query {
   获取所有用户
  users: [User!]!
   根据 ID 获取用户
  user(id: ID!): User
}

type Mutation {
   创建新用户
  createUser(name: String!, age: Int!, email: String!): User!
   更新用户信息
  updateUser(id: ID!, name: String, age: Int, email: String): User!
   删除用户
  deleteUser(id: ID!): User!
}

type Subscription {
   订阅新用户创建事件
  userCreated: User!
}




 2. GraphQL 查询示例
 2.1 查询所有用户
graphql
query {
  users {
    id
    name
    age
    email
  }
}


 2.2 查询单个用户
graphql
query {
  user(id: "1") {
    id
    name
    age
    email
  }
}




 3. GraphQL 变更示例
 3.1 创建用户
graphql
mutation {
  createUser(name: "John Doe", age: 30, email: "john@example.com") {
    id
    name
    age
    email
  }
}


 3.2 更新用户
graphql
mutation {
  updateUser(id: "1", name: "Jane Doe", age: 25) {
    id
    name
    age
    email
  }
}


 3.3 删除用户
graphql
mutation {
  deleteUser(id: "1") {
    id
    name
    age
    email
  }
}




 4. GraphQL 订阅示例
 4.1 订阅新用户创建事件
graphql
subscription {
  userCreated {
    id
    name
    age
    email
  }
}




 5. 后端实现（Node.js + Apollo Server）
以下是一个简单的后端实现，使用 Apollo Server 和 Node.js。

 5.1 安装依赖
bash
npm install apolloserver graphql


 5.2 实现代码
javascript
const { ApolloServer, gql, PubSub } = require('apolloserver');

// 发布订阅实例
const pubsub = new PubSub();

// 模拟数据
let users = [
  { id: '1', name: 'John Doe', age: 30, email: 'john@example.com' },
  { id: '2', name: 'Jane Doe', age: 25, email: 'jane@example.com' },
];

// Schema 定义
const typeDefs = gql
  type User {
    id: ID!
    name: String!
    age: Int!
    email: String!
  }

  type Query {
    users: [User!]!
    user(id: ID!): User
  }

  type Mutation {
    createUser(name: String!, age: Int!, email: String!): User!
    updateUser(id: ID!, name: String, age: Int, email: String): User!
    deleteUser(id: ID!): User!
  }

  type Subscription {
    userCreated: User!
  }
;

// 解析器
const resolvers = {
  Query: {
    users: () => users,
    user: (parent, args) => users.find(user => user.id === args.id),
  },
  Mutation: {
    createUser: (parent, args) => {
      const newUser = { id: String(users.length + 1), ...args };
      users.push(newUser);
      pubsub.publish('USER_CREATED', { userCreated: newUser }); // 发布事件
      return newUser;
    },
    updateUser: (parent, args) => {
      const userIndex = users.findIndex(user => user.id === args.id);
      if (userIndex === 1) throw new Error('User not found');
      const updatedUser = { ...users[userIndex], ...args };
      users[userIndex] = updatedUser;
      return updatedUser;
    },
    deleteUser: (parent, args) => {
      const userIndex = users.findIndex(user => user.id === args.id);
      if (userIndex === 1) throw new Error('User not found');
      const deletedUser = users.splice(userIndex, 1)[0];
      return deletedUser;
    },
  },
  Subscription: {
    userCreated: {
      subscribe: () => pubsub.asyncIterator(['USER_CREATED']), // 订阅事件
    },
  },
};

// 创建 Apollo Server
const server = new ApolloServer({ typeDefs, resolvers });

// 启动服务器
server.listen().then(({ url, subscriptionsUrl }) => {
  console.log(🚀 Server ready at ${url});
  console.log(🚀 Subscriptions ready at ${subscriptionsUrl});
});




 6. 前端调用示例（使用 Apollo Client）
以下是一个简单的前端调用示例，使用 Apollo Client。

 6.1 安装依赖
bash
npm install @apollo/client graphql


 6.2 实现代码
javascript
import { ApolloClient, InMemoryCache, gql } from '@apollo/client';

// 创建 Apollo Client
const client = new ApolloClient({
  uri: 'http://localhost:4000', // GraphQL 服务器地址
  cache: new InMemoryCache(),
});

// 查询所有用户
client.query({
  query: gql
    query {
      users {
        id
        name
        age
        email
      }
    }
  ,
}).then(result => console.log(result.data.users));

// 创建新用户
client.mutate({
  mutation: gql
    mutation {
      createUser(name: "Alice", age: 28, email: "alice@example.com") {
        id
        name
        age
        email
      }
    }
  ,
}).then(result => console.log(result.data.createUser));




 7. 总结
以上是一个完整的 GraphQL 示例，包括：
 Schema 定义：定义数据结构和操作。
 查询、变更、订阅：展示如何使用 GraphQL 操作数据。
 后端实现：使用 Apollo Server 实现 GraphQL API。
 前端调用：使用 Apollo Client 调用 GraphQL API。

通过这个示例，您可以快速上手 GraphQL，并理解其核心概念和用法。
在 Spring Boot 中实现 GraphQL 后端，可以使用 Spring GraphQL 或 GraphQL Java 库。以下是使用 Spring GraphQL 的完整示例。



 1. 环境准备
确保已安装以下工具：
 Java 17+
 Maven 或 Gradle
 Spring Boot 2.7+ 或 3.x



 2. 添加依赖
在 pom.xml 中添加 Spring GraphQL 依赖：

xml
<dependencies>
    <! Spring Boot Starter >
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>springbootstarterweb</artifactId>
    </dependency>

    <! Spring GraphQL >
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>springbootstartergraphql</artifactId>
    </dependency>

    <! Spring Data JPA (可选，用于数据库操作) >
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>springbootstarterdatajpa</artifactId>
    </dependency>

    <! H2 Database (可选，用于测试) >
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>




 3. 定义 GraphQL Schema
在 src/main/resources/graphql/schema.graphqls 中定义 GraphQL Schema：

graphql
type User {
    id: ID!
    name: String!
    age: Int!
    email: String!
}

type Query {
    users: [User!]!
    user(id: ID!): User
}

type Mutation {
    createUser(name: String!, age: Int!, email: String!): User!
    updateUser(id: ID!, name: String, age: Int, email: String): User!
    deleteUser(id: ID!): User!
}




 4. 实现数据模型
定义一个简单的 User 实体类：

java
package com.example.graphql.model;

public class User {
    private String id;
    private String name;
    private int age;
    private String email;

    // 构造函数、Getter 和 Setter
    public User(String id, String name, int age, String email) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}




 5. 实现服务层
创建一个服务类来处理业务逻辑：

java
package com.example.graphql.service;

import com.example.graphql.model.User;
import org.springframework.stereotype.Service;

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

@Service
public class UserService {
    private final List<User> users = new ArrayList<>();

    public List<User> getAllUsers() {
        return users;
    }

    public User getUserById(String id) {
        return users.stream()
                .filter(user > user.getId().equals(id))
                .findFirst()
                .orElseThrow(() > new RuntimeException("User not found"));
    }

    public User createUser(String name, int age, String email) {
        User user = new User(UUID.randomUUID().toString(), name, age, email);
        users.add(user);
        return user;
    }

    public User updateUser(String id, String name, Integer age, String email) {
        User user = getUserById(id);
        if (name != null) user.setName(name);
        if (age != null) user.setAge(age);
        if (email != null) user.setEmail(email);
        return user;
    }

    public User deleteUser(String id) {
        User user = getUserById(id);
        users.remove(user);
        return user;
    }
}




 6. 实现 GraphQL 控制器
使用 @QueryMapping 和 @MutationMapping 注解实现 GraphQL 查询和变更：

java
package com.example.graphql.controller;

import com.example.graphql.model.User;
import com.example.graphql.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.graphql.data.method.annotation.Argument;
import org.springframework.graphql.data.method.annotation.MutationMapping;
import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.Controller;

import java.util.List;

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @QueryMapping
    public List<User> users() {
        return userService.getAllUsers();
    }

    @QueryMapping
    public User user(@Argument String id) {
        return userService.getUserById(id);
    }

    @MutationMapping
    public User createUser(@Argument String name, @Argument int age, @Argument String email) {
        return userService.createUser(name, age, email);
    }

    @MutationMapping
    public User updateUser(
            @Argument String id,
            @Argument String name,
            @Argument Integer age,
            @Argument String email) {
        return userService.updateUser(id, name, age, email);
    }

    @MutationMapping
    public User deleteUser(@Argument String id) {
        return userService.deleteUser(id);
    }
}




 7. 配置 Spring Boot 应用
在 src/main/resources/application.properties 中配置 GraphQL 端点：

properties
 启用 GraphQL 端点
spring.graphql.graphiql.enabled=true
spring.graphql.path=/graphql




 8. 运行应用
启动 Spring Boot 应用后，访问以下 URL：
 GraphQL 端点：http://localhost:8080/graphql
 GraphiQL 界面：http://localhost:8080/graphiql（用于测试 GraphQL 查询）



 9. 测试 GraphQL 查询
 9.1 查询所有用户
graphql
query {
  users {
    id
    name
    age
    email
  }
}


 9.2 创建用户
graphql
mutation {
  createUser(name: "John Doe", age: 30, email: "john@example.com") {
    id
    name
    age
    email
  }
}


 9.3 更新用户
graphql
mutation {
  updateUser(id: "1", name: "Jane Doe", age: 25) {
    id
    name
    age
    email
  }
}


 9.4 删除用户
graphql
mutation {
  deleteUser(id: "1") {
    id
    name
    age
    email
  }
}




 10. 总结
通过以上步骤，您可以在 Spring Boot 中实现一个完整的 GraphQL 后端，支持查询、变更等操作。Spring GraphQL 提供了简洁的注解和配置方式，使得开发 GraphQL API 更加高效。

 建议
 扩展功能：可以结合 Spring Data JPA 实现数据库持久化。
 性能优化：使用 DataLoader 优化 N+1 查询问题。
 安全性：结合 Spring Security 实现权限控制。

golang使用http发送graphql请求
12-27 1003
请求内容： query格式： query UnitList($Ids: String!, $offset: Int! ){UnitList(searchParams: {Ids: $Ids, offset: $offset}, searchType: BASE) {list { score score_addbusinesstravel UnitTags commentScore } isOv...
GraphQL+SpringBoot入门指南
JAVYthon的博客
12-21 1406
定义接口返回值类型，一般命名风格：入参为input结尾，返回值payload结尾age: Int,# 定义查询接口Schema这样在其他文件就可以使用extend关键字来继续使用Query和Mutation了，否则schema是不允许定义多个Query和Mutation的，解耦的效果就达不到了# 查询接口# eg:# 增删改接口# eg:# 在另外一个文件就可以这样写：查询接口@Slf4j@Component@Override} else {.build();",
探索高效能的GraphQL服务：graphql-http
gitblog_00057的博客
05-26 278
探索高效能的GraphQL服务：graphql-http graphql-httpSimple, pluggable, zero-dependency, GraphQL over HTTP spec compliant server, client and audit suite.项目地址:https://gitcode.com/gh_mirrors/gr/graphql-http 在今天的软件...
Spring Boot中使用GraphQL
qq_21305943的专栏
07-24 1714
传统的 REST API 使用服务器管理资源的概念。我们可以使用各种HTTP请求以一些标准方式操作这些资源。只要我们的 API 符合资源概念，这就可以很好地工作，但当我们需要偏离它时，很快就会分崩离析。当客户端需要同时来自多个资源的数据时，例如请求博客文章和评论时，也会受到影响。通常，这是通过让客户端发出多个请求或让服务器提供可能并不总是需要的额外数据来解决的，从而导致更大的响应大小。GraphQL 为这两个问题提供了解决方案。
Spring Boot 对Spring for GraphQL的支持
听海边涛声
02-16 1120
Spring Boot 对Spring for GraphQL的支持
Graphql学习(五)-Http请求规范
z69183787的专栏
02-03 6052
GraphQL HTTP 服务器一般都可以处理 HTTP 的 POST 方法，有的还可以处理 GET 方法。 GET 请求 用 GET 请求查询 GraphQL 服务器时，应当将查询的文档，变量和操作名称作为 GET 参数传给服务器。 完整的参数格式：?query=查询文档&amp;variables=变量&amp;operationName=操作名称。 query：查询文档，必填。 vari...
基于GraphQL理念的Java后台接口设计源码方案
10-05
而“sample”可能代表示例代码或者示例项目，“support-android”和“springboot-core”则分别表明了项目支持的Android平台以及其核心为基于Spring Boot框架的后端实现。 该项目将GraphQL的查询能力和Java后端开发...
Spring Boot+Vue前后端分离Java开发框架
资源摘要信息:"基于Spring Boot与Vue的前后端分离Java快速开发框架" 知识点概述: 1. Spring Boot快速开发框架: - Spring Boot是基于Spring的一套快速开发框架，目的在于简化Spring应用的初始搭建以及开发过程。 ...
springboot集成graphql-java
Six_Ge_BM的博客
12-06 595
首先添加pom依赖 <!-- graphQL begin--> <dependency> <groupId>com.graphql-java</groupId> <artifactId>graphql-spring-boot-starter&lt...
SpringBoot GraphQL DGS 框架开发指南
飞凌雪的专栏
03-03 2374
入门 创建一个新的Spring Boot应用程序 DGS框架基于Spring Boot，因此，如果您还没有一个新的Spring Boot应用程序，请先开始。Spring Initializr是一种简便的方法。您可以使用Gradle或Maven，Java 8或更高版本，也可以使用Kotlin。我们推荐Gradle，因为我们有一个非常酷的代码生成插件！ 唯一需要的Spring依赖项是Spring Web。 在IDE中打开项目（建议使用Intellij）。 添加[DGS]框架依赖性...
使用Spring Boot集成GraphQL
weixin_40469131的博客
07-15 211
使用Spring Boot集成GraphQL 大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ GraphQL是一种用于API的查询语言，提供了一个强大的工具来实现灵活和高效的数据查询。在这篇文章中，我们将介绍如何在Spring Boot应用程序中集成GraphQL。我们将一步一步地展示如何设...
推荐使用 GraphQL 的新时代：graphql-http
gitblog_00033的博客
05-11 409
推荐使用 GraphQL 的新时代：graphql-http express-graphqlCreate a GraphQL HTTP server with Express.项目地址:https://gitcode.com/gh_mirrors/ex/express-graphql 随着技术的发展和标准的规范化，古老的 express-graphql 已经进入了历史的篇章，取而代之的是新一代官...
如何在Spring Boot中使用GraphQL
微赚淘客系统开发者博客
07-06 992
通过本文的介绍，我们了解了如何在Spring Boot应用中集成和使用GraphQL。在选择API设计方式时，根据项目需求和团队技术栈的情况，可以考虑是否使用GraphQL来提升API的灵活性和效率。它提供了一种更高效、强大和灵活的方式来设计API，并且允许客户端请求精确地获取需要的数据，而不是像传统RESTful API那样固定返回整个数据结构。今天我们将探讨如何在Spring Boot应用中集成和使用GraphQL，这是一种强大且灵活的API查询语言。中配置GraphQL的路径和相关属性。
Java对接GraphQL
最新发布
nonagontech的博客
11-05 1128
Java对接GraphQL
graphQL相关
qq_34648165的博客
01-29 183
入门介绍 GraphQL 是一个用于 API 的查询语言，是一个使用基于类型系统来执行查询的服务端运行时（类型系统由你的数据定义）。GraphQL 并没有和任何特定数据库或者存储引擎绑定，而是依靠你现有的代码和数据支撑。 查询和其结果拥有几乎一样的结构。这是 GraphQL 最重要的特性，因为这样一来，你就总是能得到你想要的数据，而服务器也准确地知道客户端请求的字段。 GraphQL 查询能够遍历相关对象及其字段，使得客户端可以一次请求查询大量相关数据，而不像传统 REST 架构中那样需要多次..
GraphQL 在 HTTP/2 世界中仍然有意义吗？
u010199413的专栏
02-23 513
大约一周前，Phil Sturgeon的这则推文激起了许多 GraphQL 爱好者的关注。 相关上下文：https://apisyouwonthate.com/blog/lets-stop-building-apis-around-a-network-hack 大约在同一时间，创建了这个名为Vulcain的项目。（这看起来还不错！）公告的一部分包括“ 您不再需要#GraphQL！...
GraphQL与REST——两种HTTP API的差异
360linker
12-11 1866
GraphQL目前被认为是革命性的API工具，因为它可以让客户端在请求中指定希望得到的数据，而不像传统的REST那样只能呆板地在服务端进行预定义。这样它就让前、后端团队的协作变得比以往更加的通畅，从而能够让组织更好地运作。而实际上，GraphQL与REST都是基于HTTP进行数据的请求与接收，而且GraphQL也内置了很多REST模型的元素在里面。 那么在技术层面上，GraphQL和REST这两...
JavaEE：GraphQL使用
a526001650a的专栏
08-17 505
说明： GraphQL是API规范，实现需要什么数据时就获取什么数据，避免垃圾数据的返回，能整合多个接口的数据一起返回，提高客户端用户体验。 一、查询规范： 请求接口时，用GQL客户端或浏览器GQL插件发送如下"查询字符串格式"，接口会返回相应json格式。 1.字段： 查询字符串格式： { user { name } } 返回json格式： { “data”: { “user”: { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值