SpringMVC项目Rest风格

于 2022-11-06 20:30:15 发布
阅读量389 收藏 2
点赞数 2
分类专栏： SpringMVC 文章标签： java http spring servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37726813/article/details/127720426
版权

1. REST简介

  • REST（Representational State Transfer），表现形式状态转换,它是一种软件架构风格

    当我们想表示一个网络资源的时候，可以使用两种方式:

    • 传统风格资源描述形式
      • http://localhost/user/getById?id=115 查询id为1的用户信息
      • http://localhost/user/saveUser 保存用户信息
    • REST风格描述形式
      • http://localhost/user/115
      • http://localhost/user

传统方式一般是一个请求url对应一种操作，这样做不仅麻烦，也不安全，因为会程序的人读取了你的请求url地址，就大概知道该url实现的是一个什么样的操作。

查看REST风格的描述，你会发现请求地址变的简单了，并且光看请求URL并不是很能猜出来该URL的具体功能

所以REST的优点有:

  • 隐藏资源的访问行为，无法通过地址得知对资源是何种操作
  • 书写简化

但是我们的问题也随之而来了，一个相同的url地址即可以是新增也可以是修改或者查询，那么到底我们该如何区分该请求到底是什么操作呢?

  • 按照REST风格访问资源时使用行为动作区分对资源进行了何种操作
    • http://localhost/users 查询全部用户信息 GET（查询）
    • http://localhost/users/115 查询指定用户信息 GET（查询）
    • http://localhost/users 添加用户信息 POST（新增/保存）
    • http://localhost/users 修改用户信息 PUT（修改/更新）
    • http://localhost/users/115 删除用户信息 DELETE（删除）

请求的方式比较多，但是比较常用的就4种，分别是GET,POST,PUT,DELETE。

按照不同的请求方式代表不同的操作类型。

  • 发送GET请求是用来做查询
  • 发送POST请求是用来做新增
  • 发送PUT请求是用来做修改
  • 发送DELETE请求是用来做删除

但是注意:

  • 上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范
    • REST提供了对应的架构方式，按照这种架构设计项目可以降低开发的复杂性，提高系统的可伸缩性
    • REST中规定GET/POST/PUT/DELETE针对的是查询/新增/修改/删除，但是我们如果非要用GET请求做删除，这点在程序上运行是可以实现的
    • 但是如果绝大多数人都遵循这种风格，你写的代码让别人读起来就有点莫名其妙了。
  • 描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如:users、books、accounts…

清楚了什么是REST风格后，我们后期会经常提到一个概念叫RESTful，那什么又是RESTful呢?

  • 根据REST风格对资源进行访问称为RESTful。

后期在进行开发的过程中，大多是都是遵从REST风格来访问后台服务，所以可以说以后都是基于RESTful来进行开发的。

2. RESTful入门案例

2.1 环境准备

  • 创建一个Web的Maven项目

  • pom.xml添加Spring依赖

    <?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.dcxuexi</groupId>
  <artifactId>springmvc_05_rest</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springmvc_05_rest Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.15.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.13.4</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
          <uriEncoding>UTF-8</uriEncoding>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

  • 创建对应的配置类

    @Configuration
@ComponentScan("com.dcxuexi.controller")
//开启json数据类型自动转换
@EnableWebMvc
public class SpringMvcConfig {
}

    public class ServlertContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    // 处理乱码

    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}
\

  • 编写模型类User

    public class User {
    private String userName;
    private Integer userAge;
    private String userSex;
    private String address;

    public User() {
    }

    public User(String userName, Integer userAge, String userSex, String address) {
        this.userName = userName;
        this.userAge = userAge;
        this.userSex = userSex;
        this.address = address;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getUserAge() {
        return userAge;
    }

    public void setUserAge(Integer userAge) {
        this.userAge = userAge;
    }

    public String getUserSex() {
        return userSex;
    }

    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", userAge=" + userAge +
                ", userSex='" + userSex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

  • 编写UserController

    @Controller
public class UserController {

    @RequestMapping("/findAll")
    @ResponseBody
    public List<User> findAll(){
        User user1 = new User("张三", 18, "男", "北京");
        User user2 = new User("李四", 24, "女", "上海");
        User user3 = new User("王二", 20, "男", "天津");
        List<User> userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        System.out.println("select userList ==>" +userList);
        return userList;
    }

    @RequestMapping("/insert")
    @ResponseBody
    public String insertUser(@RequestBody User user){
        System.out.println("insert user ==>" + user);
        return "insert user success";
    }

    @RequestMapping("/update")
    @ResponseBody
    public String updateUser(@RequestBody User user){
        System.out.println("update user ==>" + user);
        return "update user success";
    }

    @RequestMapping("/delete")
    @ResponseBody
    public String deleteUser(String userName){
        System.out.println("delete user ==>" +userName);
        return "delete user success";
    }
    
}

最终创建好的项目结构如下:

在这里插入图片描述

2.2 思路分析

需求:将之前的增删改查替换成RESTful的开发方式。

1.之前不同的请求有不同的路径,现在要将其修改为统一的请求路径

修改前: 新增: /findAll ,修改: /update,删除 /delete…

修改后: 增删改查: /users

2.根据GET查询、POST新增、PUT修改、DELETE删除对方法的请求方式进行限定

3.发送请求的过程中如何设置请求参数?

2.3 修改RESTful风格

新增

@Controller
public class UserController {
    //设置当前请求方法为POST，表示REST风格中的添加操作
    @RequestMapping(value = "/users",method = RequestMethod.POST)
    @ResponseBody
    public String insertUser(@RequestBody User user){
        System.out.println("insert user ==>" + user);
        return "insert user success";
    }
}

  • 将请求路径更改为/users

    • 访问该方法使用 POST: http://localhost/users

  • 使用method属性限定该方法的访问方式为POST

    • 如果发送的不是POST请求，比如发送GET请求，则会报错

      在这里插入图片描述

删除

@Controller
public class UserController {
    //设置当前请求方法为DELETE，表示REST风格中的删除操作
    @RequestMapping(value = "/users",method = RequestMethod.DELETE)
    @ResponseBody
    public String deleteUser(String userName){
        System.out.println("delete user ==>" +userName);
        return "delete user success";
    }
}
  • 将请求路径更改为/users
    • 访问该方法使用 DELETE: http://localhost/users

访问成功，但是删除方法没有携带所要删除数据的userName,所以针对RESTful的开发，如何携带数据参数?

传递路径参数

前端发送请求的时候使用:http://localhost/users/xiaochuang,路径中的xiaochuang就是我们想要传递的参数。

后端获取参数，需要做如下修改:

  • 修改@RequestMapping的value属性，将其中修改为/users/{userName}，目的是和路径匹配
  • 在方法的形参前添加@PathVariable注解
@Controller
public class UserController {
    //设置当前请求方法为DELETE，表示REST风格中的删除操作
    @RequestMapping(value = "/users/{userName}",method = RequestMethod.DELETE)
    @ResponseBody
    public String deleteUser(@PathVariable String userName){
        System.out.println("delete user ==>" +userName);
        return "delete user success";
    }
}

思考如下两个问题:

(1)如果方法形参的名称和路径{}中的值不一致，该怎么办?

在这里插入图片描述

(2)如果有多个参数需要传递该如何编写?

前端发送请求的时候使用:http://localhost/users/xiaochuang/28,路径中的xiaochuang和28就是我们想要传递的两个参数。

后端获取参数，需要做如下修改:

@Controller
public class UserController {
	//设置当前请求方法为DELETE，表示REST风格中的删除操作
    @RequestMapping(value = "/users/{name}/{age}",method = RequestMethod.DELETE)
    @ResponseBody
    public String deleteUser(@PathVariable("name") String userName,@PathVariable("age")Integer userAge){
        System.out.println("delete user ==>" +userName);
        System.out.println("delete user ==>" +userAge);
        return "delete user success";
    }
}

修改

@Controller
public class UserController {
    //设置当前请求方法为PUT，表示REST风格中的修改操作
    @RequestMapping(value = "/users",method = RequestMethod.PUT)
    @ResponseBody
    public String updateUser(@RequestBody User user){
        System.out.println("update user ==>" + user);
        return "update user success";
    }
}

  • 将请求路径更改为/users

    • 访问该方法使用 PUT: http://localhost/users

  • 访问并携带参数:

    在这里插入图片描述

根据userName查询

@Controller
public class UserController {
    //设置当前请求方法为GET，表示REST风格中的查询操作
    @RequestMapping(value = "/users/{userName}",method = RequestMethod.GET)
    @ResponseBody
    public User findByUserName(@PathVariable String userName){
        User user1 = new User("张三", 18, "男", "北京");
        User user2 = new User("李四", 24, "女", "上海");
        User user3 = new User("王二", 20, "男", "天津");
        List<User> userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        for (User user:userList
             ) {
            if (user.getUserName().equals(userName)){
                System.out.println("select user ==>" +user);
                return user;
            }
        }
        return new User();
    }

}

将请求路径更改为/users

  • 访问该方法使用 GET: http://localhost/users/张三

查询所有

@Controller
public class UserController {
    //设置当前请求方法为GET，表示REST风格中的查询操作
    @RequestMapping(value = "/users",method = RequestMethod.GET)
    @ResponseBody
    public List<User> findAll(){
        User user1 = new User("张三", 18, "男", "北京");
        User user2 = new User("李四", 24, "女", "上海");
        User user3 = new User("王二", 20, "男", "天津");
        List<User> userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        System.out.println("select userList ==>" +userList);
        return userList;
    }
}

将请求路径更改为/users

  • 访问该方法使用 GET: http://localhost/users

小结

RESTful入门案例，我们需要学习的内容如下:

(1)设定Http请求动作(动词)

@RequestMapping(value=“”,method = RequestMethod.POST|GET|PUT|DELETE)

(2)设定请求参数(路径变量)

@RequestMapping(value=“/users/{userName}”,method = RequestMethod.DELETE)

@ReponseBody

public String delete(@PathVariable String userName){

}

知识点1：@PathVariable

名称@PathVariable
类型形参注解
位置SpringMVC控制器方法形参定义前面
作用绑定路径参数与处理器方法形参间的关系，要求路径参数名与形参名一一对应

关于接收参数，我们学过三个注解@RequestBody、@RequestParam、@PathVariable,这三个注解之间的区别和应用分别是什么?

  • 区别
    • @RequestParam用于接收url地址传参或表单传参
    • @RequestBody用于接收json数据
    • @PathVariable用于接收路径参数，使用{参数名称}描述路径参数
  • 应用
    • 后期开发中，发送请求参数超过1个时，以json格式为主，@RequestBody应用较广
    • 如果发送非json格式数据，选用@RequestParam接收请求参数
    • 采用RESTful进行开发，当参数数量较少时，例如1个，可以采用@PathVariable接收请求路径变量，通常用于传递id值

3. RESTful快速开发

做完了RESTful的开发，你会发现好麻烦，麻烦在哪?

在这里插入图片描述

问题1：每个方法的@RequestMapping注解中都定义了访问路径/users，重复性太高。

问题2：每个方法的@RequestMapping注解中都要使用method属性定义请求方式，重复性太高。

问题3：每个方法响应json都需要加上@ResponseBody注解，重复性太高。

对于上面所提的这三个问题，具体该如何解决?

@RestController //@Controller + ReponseBody
@RequestMapping("/users")
public class UserController {

    //设置当前请求方法为GET，表示REST风格中的查询操作
    //@RequestMapping(value = "/users",method = RequestMethod.GET)
    //@ResponseBody
    @GetMapping
    public List<User> findAll(){
        User user1 = new User("张三", 18, "男", "北京");
        User user2 = new User("李四", 24, "女", "上海");
        User user3 = new User("王二", 20, "男", "天津");
        List<User> userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        System.out.println("select userList ==>" +userList);
        return userList;
    }

    //设置当前请求方法为GET，表示REST风格中的查询操作
    //@RequestMapping(value = "/users/{userName}",method = RequestMethod.GET)
    //@ResponseBody
    @GetMapping("/{userName}")
    public User findByUserName(@PathVariable String userName){
        User user1 = new User("张三", 18, "男", "北京");
        User user2 = new User("李四", 24, "女", "上海");
        User user3 = new User("王二", 20, "男", "天津");
        List<User> userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        for (User user:userList
             ) {
            if (user.getUserName().equals(userName)){
                System.out.println("select user ==>" +user);
                return user;
            }
        }
        return new User();
    }

    //设置当前请求方法为POST，表示REST风格中的添加操作
    //@RequestMapping(value = "/users",method = RequestMethod.POST)
    //@ResponseBody
    @PostMapping
    public String insertUser(@RequestBody User user){
        System.out.println("insert user ==>" + user);
        return "insert user success";
    }

    //设置当前请求方法为PUT，表示REST风格中的修改操作
    //@RequestMapping(value = "/users",method = RequestMethod.PUT)
    //@ResponseBody
    @PutMapping()
    public String updateUser(@RequestBody User user){
        System.out.println("update user ==>" + user);
        return "update user success";
    }

    //设置当前请求方法为DELETE，表示REST风格中的删除操作
    //@RequestMapping(value = "/users/{name}/{age}",method = RequestMethod.DELETE)
    //@ResponseBody
    @DeleteMapping("/{name}/{age}")
    public String deleteUser(@PathVariable("name") String userName,@PathVariable("age")Integer userAge){
        System.out.println("delete user ==>" +userName);
        System.out.println("delete user ==>" +userAge);
        return "delete user success";
    }

}

对于刚才的问题，我们都有对应的解决方案：

问题1：每个方法的@RequestMapping注解中都定义了访问路径/users，重复性太高。

将@RequestMapping提到类上面，用来定义所有方法共同的访问路径。

问题2：每个方法的@RequestMapping注解中都要使用method属性定义请求方式，重复性太高。

使用@GetMapping  @PostMapping  @PutMapping  @DeleteMapping代替

问题3：每个方法响应json都需要加上@ResponseBody注解，重复性太高。

1.将ResponseBody提到类上面，让所有的方法都有@ResponseBody的功能
2.使用@RestController注解替换@Controller与@ResponseBody注解，简化书写

知识点1：@RestController

名称@RestController
类型类注解
位置基于SpringMVC的RESTful开发控制器类定义上方
作用设置当前控制器类为RESTful风格，
等同于@Controller与@ResponseBody两个注解组合功能

知识点2：@GetMapping @PostMapping @PutMapping @DeleteMapping

名称@GetMapping @PostMapping @PutMapping @DeleteMapping
类型方法注解
位置基于SpringMVC的RESTful开发控制器方法定义上方
作用设置当前控制器方法请求访问路径与请求动作，每种对应一个请求动作，
例如@GetMapping对应GET请求
相关属性value（默认）：请求访问路径


项目代码

Mr.D.Chuang
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 中rest,Java中的REST调用
weixin_42605397的博客
03-12 1765
我对在JAVA中进行的特定REST调用有一些疑问.我是新手,所以我从多个来源将其进行了整理.呼叫本身如下所示：String src = AaRestCall.subTrackingNum(trackingNum);Rest调用类如下所示：public class AaRestCall {public static String subTrackingNum (Sting trackingNum) ...
Java调用REST接口（get，post请求方法）
瑶少的博客
06-30 1万+
网上的调用方法实例千奇百怪，以下为本人自己整理的Java调用rest接口方法实例，包含get请求和post请求，可创建工具类方便调用，其中post请求解决了入出参中文乱码问题。 get方式请求 //get方式请求 public String restCallerGet(String path, String param) { //path 接口路径 xxx/xxx/xxx //param 入参 ?xxx=x&xxx=x&xxx=x //接口ip String http
java rest 架构,SpringMVC互联网软件架构REST使用详解
weixin_29645033的博客
03-12 204
什么是RESTREST:即 Representational State Transfer。(资源)表现层状态转化。是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便,所以正得到越来越多网站的采用☐ 资源(Resources):网络上的一个实体,或者说是网络上的一个具体信息。它可以是一段文本、一张图片、一首歌曲、一种服务,总之就是一个具体的存在。可以用一个URI(统一资源定...
java rest 图_Java REST框架一览
weixin_39787594的博客
02-16 182
【REST技术】在这个时代，一方面是计算机科学家们不断的试图提高计算机表示的抽象能力使之更好的为现实世界服务，使人们能够更简单的利用计算机，一方面却是复杂性的不断提高。易用相对于用户，但是把复杂性留给了程序员。于是计算机科学家们一直在不停的想办法，力图降低程序员工作的复杂度。那么REST(representation tranfer state)技术就在这种背景下孕育而生。当今的Web服务属于大型...
java rest 请求_REST 风格的请求方式
weixin_30140093的博客
02-13 1002
REST：即 Representational State Transfer。(资源)表现层状态转化。是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便， 所以正得到越来越多网站的采用。使用 REST 风格的请求方式，可以简化 url，达到使用同一个 url 不同请求方式来执行不同的方法。REST 风格的请求方式分别对应了以下四种请求，这四种请求有分别对应了四种对资源的操作...
SpringMVC-REST风格和SSM整合（注解版）彩色PPT版本.pptx
最新发布
06-01
REST风格简介 2、RESTful入门案例 入门案例 请求方法设定 请求路径参数 3、REST快速开发 RESTful快速开发（标准开发） @RestController 标准请求动作映射（4种） 4、案例：基于RESTful页面数据交互 5、SSM整合 ...
springmvc之rest风格的crud
09-16
在Spring MVC框架中，REST（Representational State Transfer）风格是一种设计Web服务的常见方式，它强调资源的概念，并通过HTTP协议中的方法（GET、POST、PUT、DELETE）来操作这些资源。本教程主要针对初学者，讲解...
springMVC rest风格视图解析
05-03
本篇文章将深入探讨Spring MVC如何实现REST风格的视图解析，以及如何根据请求的后缀名返回JSON或XML格式的数据。 首先，我们需要理解Spring MVC中的DispatcherServlet是如何工作的。DispatcherServlet是Spring MVC...
SpringMVC构建REST接口的源代码
05-23
REST（Representational State Transfer）是一种软件架构风格，常用于构建网络应用，尤其是Web服务。REST接口设计强调资源的定位和状态转换，通过HTTP方法（如GET、POST、PUT、DELETE等）来操作这些资源。 本源代码...
SpringMVC+REST+AngularJS框架
11-24
在`Angular_SpringMVC_test`这个项目中，我们可以看到一个具体的实现示例，包括SpringMVC的配置、REST API接口定义、AngularJS的控制器和服务以及视图模板。通过研究这个示例，开发者可以更好地理解如何将这三个强大...
Java调用外部REST请求的几种方式
伍六七的博客
08-17 1262
1 restTemplate — spring 提供 特点： 1、RestOperations 提供了各种封装方法，非常方便直接将返回转成实体类。 2、默认使用JDK 的HttpURLConnection进行通信，但是可以通过RestTemplate.setRequestFactory 切换到不同的HTTP源：如Apache HttpComponents、Netty、OkHttp。 3、支持同步、异步请求； 4、支持更多的定制，比如拦截器等。 ps：支持 get 请求，参数是 body 的形式。 参考：ht
什么是java REST与RESTFUL
滕益宏的博客
04-10 8143
越来越多的人开始意识到，网站即软件，而且是一种新型的软件。 这种"互联网软件"采用客户端/服务器模式，建立在分布式体系上，通过互联网通信，具有高延时（high latency）、高并发等特点。 网站开发，完全可以采用软件开发的模式。但是传统上，软件和网络是两个不同的领域，很少有交集；软件开发主要针对单机环境，网络则主要研究系统之间的通信。互联网的兴起，使得这两个领域开始融合，现在我们必
SpringMVC REST风格
qq_43560701的博客
08-31 221
SpringMVC REST风格 本节新建 SpringMVC-05-REST 项目研究一下 REST 风格的使用，项目基本配置已经做好，后面就不说了！ 1. REST介绍 REST 即 Representational State Transfer，意为表示层状态传递，是一种软件架构风格，可以降低开发的复杂性，提高系统的可伸缩性。REST 是一组架构约束条件和原则，满足这些约束条件和原则的应用程序或设计就是 RESTful。 首先，互联网上的信息都可以被抽象为资源，用户可以发起请求对这些资源进行操作，操作
当REST遇上Java
googlevsbing的专栏
06-24 4192
当REST遇上Java今天我们来一起学习和了解rest的相关知识，做后台程序的或多说少都听说过甚至使用过rest技术，但很多同学可能都没有真正了解什么是rest，这里我们就一起来学习一下。rest的前世今生一、起源 REST这个词，是Roy Thomas Fielding在他2000年的博士论文中提出的。 Fielding是一个非常重要的人，他是HTTP协议（1.0版和1.1版）的主要设计者、A
rest java实例_REST例子
weixin_30449853的博客
02-12 249
REST的例子与web service类似，REST利用一个更加接近http的协议传递数据。请求的目的地即是一个URI，数据的格式可以是XML、JSON或者是纯文本。下面是一个在myeclipse 8.6上的REST小例子，还很不完善先记录下来。部署REST服务：web service project, 选择了REST的web servicepackagecom.test;importjava...
java 轻量级 RestClient
Rocky的专栏
05-18 2107
java 轻量级 RestClient package org.rx.socks.http; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import net.sf.cglib.proxy.Enhancer; import net.sf.cg...
Java调用Rest请求
山月神话
11-14 3127
package com.db; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; import java.util.List; public cl...
java调用rest接口
热门推荐
月光疾风的博客
11-21 1万+
package com.boco.gaia.service.mockalarm.util; import java.io.IOException; import java.text.MessageFormat; import java.util.ArrayList; import java.util.List; import java.util.concurrent.TimeUnit; im...
SpringMVC使用（一）——@RequestMapping处理请求
北风之神096的IT人生
02-15 909
本文转自:http://my.oschina.net/zhdkn/blog/316530 对于各种注解而言，排第一的当然是“@Controller”,表明某类是一个controller。 “@RequestMapping”请求路径映射，如果标注在某个controller的类级别上，则表明访问此类路径下的方法都要加上其配置的路径；最常用是标注在方法上，表明哪个具体的方法来接受处理某次请求
SpringMVC 3.0实战详解：REST风格与注解驱动
它支持RESTful风格的URL设计，使得API的设计更加清晰和直观。 2. **HTTP请求地址映射** 在Spring MVC中，`@RequestMapping`注解用于指定控制器类和方法的URL映射。例如，`@Controller`注解将`UserController`类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mr.D.Chuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值