转载

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

REST（Representational State Transfer）,中文翻译叫“表述性状态转移”。是 Roy Thomas Fielding 在他2000年的博士论文中提出的。它与传统的 SOAP Web 服务区别在于，REST关注的是要处理的数据，而 SOAP 主要关注行为和处理。要理解好 REST，根据其首字母拆分出的英文更容易理解。

表述性（Representational）:对于 REST 来说，我们网络上的一个个URI资源可以用各种形式来表述，例如：XML、JSON或者HTML等。

状态（State）：REST 更关注资源的状态而不是对资源采取的行为。

转移（Transfer）：在网络传输过程中，REST 使资源以某种表述性形式从一个应用转移到另一个应用（如从服务端转移到客户端）。

具体来说，REST 中存在行为，它的行为是通过 HTTP 表示操作的方法来定义的即：GET、POST、PUT、DELETE、PATCH；GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源，PATCH用来更新资源。 基于 REST 这样的观点，我们需要避免使用 REST服务、REST Web服务 这样的称呼，这些称呼多少都带有一些强调行为的味道。

二、使用 RESTful 架构设计使用误区

**RESTful 架构：**是基于 REST 思想的时下比较流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。

在没有足够了解 REST 的时候，我们很容易错误的将其视为 “基于 URL 的 Web 服务”，即将 REST 和 SOAP 一样，是一种远程过程调用（remote procedure call，RPC）的机制。但是 REST 和 RPC 几乎没有任何关系，RPC 是面向服务的，而 REST 是面向资源的，强调描述应用程序的事物和名词。这样很容易导致的一个结果是我们在设计 RESTful API 时，在 URI 中使用动词。例如： GET /user/getUser/123 。正确写法应该是 GET /user/123 。

三、 springMVC 支持 RESTful

在 spring 3.0 以后，spring 这对 springMVC 的一些增强功能对 RESTful 提供了良好的支持。在4.0后的版本中，spring 支持一下方式创建 REST 资源：

  1. 控制器可以处理所有的 HTTP 方法，包含几个主要的 REST 方法： GET、POST、PUT、DELETE、PATCH ；

  2. 借助 spring 的视图解析器，资源能够以多种方式进行表述，包括将模型数据渲染为 XML、JSON、Atom、已经 RSS 的 View 实现；

  3. 可以使用 ContentNegotiatingViewResolver 来选择最适合客户端的表述；

  4. 借助 @ResponseBody 注解和各种 HttpMethodConverter 实现，能够替换基于视图的渲染方式；

  5. 类似地， @RequestBody 注解以及 HttpMethodConverter 实现可以将传入的 HTTP 数据转化为传入控制器处理方法的 Java 对象；

  6. 借助 RestTemplate ，spring 应用能够方便地使用 REST 资源。

四、基于Rest的Controller（控制器）

我们的 REST API :

  • GET 方式请求 /api/user/ 返回用户列表
  • GET 方式请求 /api/user/1返回id为1的用户
  • POST 方式请求 /api/user/ 通过user对象的JSON 参数创建新的user对象
  • PUT 方式请求 /api/user/3 更新id为3的发送json格式的用户对象
  • DELETE 方式请求/api/user/4删除 ID为 4的user对象
  • DELETE 方式请求/api/user/删除所有user
package com.websystique.springmvc.controller;  
       
    import java.util.List;  
       
    import org.springframework.beans.factory.annotation.Autowired;  
    import org.springframework.http.HttpHeaders;  
    import org.springframework.http.HttpStatus;  
    import org.springframework.http.MediaType;  
    import org.springframework.http.ResponseEntity;  
    import org.springframework.web.bind.annotation.PathVariable;  
    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.RestController;  
    import org.springframework.web.util.UriComponentsBuilder;  
       
    import com.websystique.springmvc.model.User;  
    import com.websystique.springmvc.service.UserService;  
       
    @RestController  
    public class HelloWorldRestController {  
       
        @Autowired  
        UserService userService;  //Service which will do all data retrieval/manipulation work  
       
           
        //-------------------Retrieve All Users--------------------------------------------------------  
           
        @RequestMapping(value = "/user/", method = RequestMethod.GET)  
        public ResponseEntity<List<User>> listAllUsers() {  
            List<User> users = userService.findAllUsers();  
            if(users.isEmpty()){  
                return new ResponseEntity<List<User>>(HttpStatus.NO_CONTENT);//You many decide to return HttpStatus.NOT_FOUND  
            }  
            return new ResponseEntity<List<User>>(users, HttpStatus.OK);  
        }  
       
       
        //-------------------Retrieve Single User--------------------------------------------------------  
           
        @RequestMapping(value = "/user/{id}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)  
        public ResponseEntity<User> getUser(@PathVariable("id") long id) {  
            System.out.println("Fetching User with id " + id);  
            User user = userService.findById(id);  
            if (user == null) {  
                System.out.println("User with id " + id + " not found");  
                return new ResponseEntity<User>(HttpStatus.NOT_FOUND);  
            }  
            return new ResponseEntity<User>(user, HttpStatus.OK);  
        }  
       
           
           
        //-------------------Create a User--------------------------------------------------------  
           
        @RequestMapping(value = "/user/", method = RequestMethod.POST)  
        public ResponseEntity<Void> createUser(@RequestBody User user,    UriComponentsBuilder ucBuilder) {  
            System.out.println("Creating User " + user.getName());  
       
            if (userService.isUserExist(user)) {  
                System.out.println("A User with name " + user.getName() + " already exist");  
                return new ResponseEntity<Void>(HttpStatus.CONFLICT);  
            }  
       
            userService.saveUser(user);  
       
            HttpHeaders headers = new HttpHeaders();  
            headers.setLocation(ucBuilder.path("/user/{id}").buildAndExpand(user.getId()).toUri());  
            return new ResponseEntity<Void>(headers, HttpStatus.CREATED);  
        }  
       
           
        //------------------- Update a User --------------------------------------------------------  
           
        @RequestMapping(value = "/user/{id}", method = RequestMethod.PUT)  
        public ResponseEntity<User> updateUser(@PathVariable("id") long id, @RequestBody User user) {  
            System.out.println("Updating User " + id);  
               
            User currentUser = userService.findById(id);  
               
            if (currentUser==null) {  
                System.out.println("User with id " + id + " not found");  
                return new ResponseEntity<User>(HttpStatus.NOT_FOUND);  
            }  
       
            currentUser.setName(user.getName());  
            currentUser.setAge(user.getAge());  
            currentUser.setSalary(user.getSalary());  
               
            userService.updateUser(currentUser);  
            return new ResponseEntity<User>(currentUser, HttpStatus.OK);  
        }  
       
        //------------------- Delete a User --------------------------------------------------------  
           
        @RequestMapping(value = "/user/{id}", method = RequestMethod.DELETE)  
        public ResponseEntity<User> deleteUser(@PathVariable("id") long id) {  
            System.out.println("Fetching & Deleting User with id " + id);  
       
            User user = userService.findById(id);  
            if (user == null) {  
                System.out.println("Unable to delete. User with id " + id + " not found");  
                return new ResponseEntity<User>(HttpStatus.NOT_FOUND);  
            }  
       
            userService.deleteUserById(id);  
            return new ResponseEntity<User>(HttpStatus.NO_CONTENT);  
        }  
       
           
        //------------------- Delete All Users --------------------------------------------------------  
           
        @RequestMapping(value = "/user/", method = RequestMethod.DELETE)  
        public ResponseEntity<User> deleteAllUsers() {  
            System.out.println("Deleting All Users");  
       
            userService.deleteAllUsers();  
            return new ResponseEntity<User>(HttpStatus.NO_CONTENT);  
        }  
       
    }

springmvc注解详解

@RestController :首先我们使用的是Spring 4的新注解 @RestController注解.

此注解避免了每个方法都要加上@ResponseBody注解。也就是说@RestController 自己戴上了 @ResponseBody注解,看以看作是

@RequestBody : 如果方法参数被 @RequestBody注解，Spring将绑定HTTP请求体到那个参数上。如果那样做，Spring将根据请求中的ACCEPT或者 Content-Type header（私下）使用 HTTP Message converters 来将http请求体转化为domain对象。

@ResponseBody : 如果方法加上了@ResponseBody注解，Spring返回值到响应体。如果这样做的话，Spring将根据请求中的 Content-Type header（私下）使用 HTTP Message converters 来将domain对象转换为响应体。

ResponseEntity ： 是一个真实数据.它代表了整个 HTTP 响应（response）. 它的好处是你可以控制任何对象放到它内部。

你可以指定状态码、头信息和响应体。它包含你想要构建HTTP Response 的信息。

@PathVariable ： 此注解意味着一个方法参数应该绑定到一个url模板变量[在'{}'里的一个]中

一般来说你，要实现REST API in Spring 4 需要了解@RestController , @RequestBody, ResponseEntity 和 @PathVariable 这些注解 .另外, spring 也提供了一些支持类帮助你实现一些可定制化的东西。

MediaType : 带着 @RequestMapping 注解,通过特殊的控制器方法你可以额外指定,MediaType来生产或者消耗。

五、发布和测试此API

想要测试此API，我将使用POSTMAN这个外部客户端，接下来我们也将写我们自己的客户端。

1. 获取所有用户

打开 POSTMAN工具，选择请求类型为GET，指明uri

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

注意：我们没有指明任何HTTP头。点击 发送，将接收到所有用户的列表

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

也要注意HTTP 200 响应。

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

你也许好奇为什么此响应通过JSON字符串发送的，在响应里的Content-Type 头说明了这个。 因为我们添加了JACKSON

<dependency>  
        <groupId>com.fasterxml.jackson.core</groupId>  
        <artifactId>jackson-databind</artifactId>  
        <version>2.5.3</version>  
    </dependency

因为Spring在类路径发现了这个库，它调用了内置的 MappingJackson2HttpMessageConverter 转换器将响应（对象集合）转换为JSON格式。 Spring内置转换器的好处是，大部分情况下只要把库放到类路径，即可完成转换。当然了有时候我们也需要 采用我们的API。比如，如果我们像也提供XML格式的话，我们需要对User类加上JAXB注解。

2. 获取单个用户

GET方式 指定 /user/1

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

现在试着发送一个带有错误识别码的GET请求，将收到一个HTTP 404

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

3.创建一个 User

选择POST方法，指明 uri /user/ 指明POSTMAN Body选项卡，选择 application/json 类型

SpringMVC+RestFul详细示例实战教程（实现跨域访问）
你要注意POSTMAN自动添加了 Content-Type

头信息

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

记住： Accept header 包含client能给识别的类型。 Content-Type header 表示数据的实际类型。

点击发送以后 将收到 HTTP 200 没有响应体（api里面没有在响应体发送任何东西）

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

你可以查询新创建的用户

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

这是实现REST的普通实现方式。但是也没人阻止你为POST或者PUT方式响应体里发送内容。但是这还是REST 的API？值得怀疑。 不管怎样，我们试着创建同一个用户时，你将获得HTTP冲突的响应。

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

4.更新用户

发送一个HTTP PUT 请求来更新用户。

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

**注意：**这次我们接收到了响应体。这是因为在控制器的方法实现里我们发送了数据。再次强调，有的人也许不在响应体里面发送更新的详情，只发送位置头（和创建用户一样）。

5.删除用户

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

6 删除所有用户

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

7.删除用户后验证

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

六、根据RestTemplate 写REST Client

Postman是测试Rest Api的超好用的工具，但是如果你想完整的消化REST，可以尝试自己写一个。 最出名的Htpp 客户端是HttpClient（ Apache HttpComponents ）。 但是用它来访问REST service则相对少见。 Spring的 RestTemplate 随之出现。RestTemplate 提供了高级方法，来响应者6种主要的HTTP方法。

HTTP 方法和对应的 RestTemplate方法:

  • HTTP GET : getForObject, getForEntity
  • HTTP PUT : put(String url, Object request, String…​urlVariables)
  • HTTP DELETE : delete
  • HTTP POST : postForLocation(String url, Object request, String…​ urlVariables), postForObject(String url, Object request, ClassresponseType, String…​ uriVariables)
  • HTTP HEAD : headForHeaders(String url, String…​ urlVariables)
  • HTTP OPTIONS : optionsForAllow(String url, String…​ urlVariables)
  • HTTP PATCH and others : exchange execute

定义 Rest client , 定义REST services

package com.websystique.springmvc;  
       
    import java.net.URI;  
    import java.util.LinkedHashMap;  
    import java.util.List;  
       
    import org.springframework.web.client.RestTemplate;  
       
    import com.websystique.springmvc.model.User;  
       
    public class SpringRestTestClient {  
       
        public static final String REST_SERVICE_URI = "http://localhost:8080/Spring4MVCCRUDRestService";  
           
        /* GET */  
        @SuppressWarnings("unchecked")  
        private static void listAllUsers(){  
            System.out.println("Testing listAllUsers API-----------");  
               
            RestTemplate restTemplate = new RestTemplate();  
            List<LinkedHashMap<String, Object>> usersMap = restTemplate.getForObject(REST_SERVICE_URI+"/user/", List.class);  
               
            if(usersMap!=null){  
                for(LinkedHashMap<String, Object> map : usersMap){  
                    System.out.println("User : id="+map.get("id")+", Name="+map.get("name")+", Age="+map.get("age")+", Salary="+map.get("salary"));;  
                }  
            }else{  
                System.out.println("No user exist----------");  
            }  
        }  
           
        /* GET */  
        private static void getUser(){  
            System.out.println("Testing getUser API----------");  
            RestTemplate restTemplate = new RestTemplate();  
            User user = restTemplate.getForObject(REST_SERVICE_URI+"/user/1", User.class);  
            System.out.println(user);  
        }  
           
        /* POST */  
        private static void createUser() {  
            System.out.println("Testing create User API----------");  
            RestTemplate restTemplate = new RestTemplate();  
            User user = new User(0,"Sarah",51,134);  
            URI uri = restTemplate.postForLocation(REST_SERVICE_URI+"/user/", user, User.class);  
            System.out.println("Location : "+uri.toASCIIString());  
        }  
       
        /* PUT */  
        private static void updateUser() {  
            System.out.println("Testing update User API----------");  
            RestTemplate restTemplate = new RestTemplate();  
            User user  = new User(1,"Tomy",33, 70000);  
            restTemplate.put(REST_SERVICE_URI+"/user/1", user);  
            System.out.println(user);  
        }  
       
        /* DELETE */  
        private static void deleteUser() {  
            System.out.println("Testing delete User API----------");  
            RestTemplate restTemplate = new RestTemplate();  
            restTemplate.delete(REST_SERVICE_URI+"/user/3");  
        }  
       
       
        /* DELETE */  
        private static void deleteAllUsers() {  
            System.out.println("Testing all delete Users API----------");  
            RestTemplate restTemplate = new RestTemplate();  
            restTemplate.delete(REST_SERVICE_URI+"/user/");  
        }  
       
        public static void main(String args[]){  
            listAllUsers();  
            getUser();  
            createUser();  
            listAllUsers();  
            updateUser();  
            listAllUsers();  
            deleteUser();  
            listAllUsers();  
            deleteAllUsers();  
            listAllUsers();  
        }  
    }

重启服务器，运行上面的程序。

下面是输出：

Testing listAllUsers API-----------  
    User : id=1, Name=Sam, Age=30, Salary=70000.0  
    User : id=2, Name=Tom, Age=40, Salary=50000.0  
    User : id=3, Name=Jerome, Age=45, Salary=30000.0  
    User : id=4, Name=Silvia, Age=50, Salary=40000.0  
    Testing getUser API----------  
    User [id=1, name=Sam, age=30, salary=70000.0]  
    Testing create User API----------  
    Location : http://localhost:8080/Spring4MVCCRUDRestService/user/5  
    Testing listAllUsers API-----------  
    User : id=1, Name=Sam, Age=30, Salary=70000.0  
    User : id=2, Name=Tom, Age=40, Salary=50000.0  
    User : id=3, Name=Jerome, Age=45, Salary=30000.0  
    User : id=4, Name=Silvia, Age=50, Salary=40000.0  
    User : id=5, Name=Sarah, Age=51, Salary=134.0  
    Testing update User API----------  
    User [id=1, name=Tomy, age=33, salary=70000.0]  
    Testing listAllUsers API-----------  
    User : id=1, Name=Tomy, Age=33, Salary=70000.0  
    User : id=2, Name=Tom, Age=40, Salary=50000.0  
    User : id=3, Name=Jerome, Age=45, Salary=30000.0  
    User : id=4, Name=Silvia, Age=50, Salary=40000.0  
    User : id=5, Name=Sarah, Age=51, Salary=134.0  
    Testing delete User API----------  
    Testing listAllUsers API-----------  
    User : id=1, Name=Tomy, Age=33, Salary=70000.0  
    User : id=2, Name=Tom, Age=40, Salary=50000.0  
    User : id=4, Name=Silvia, Age=50, Salary=40000.0  
    User : id=5, Name=Sarah, Age=51, Salary=134.0  
    Testing all delete Users API----------  
    Testing listAllUsers API-----------  
    No user exist----------

七、完整的例子

1、项目结构

SpringMVC+RestFul详细示例实战教程（实现跨域访问）

2、pom.xml添加项目依赖

<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/maven-v4_0_0.xsd">  
      <modelVersion>4.0.0</modelVersion>  
      <groupId>com.websystique.springmvc</groupId>  
      <artifactId>Spring4MVCCRUDRestService</artifactId>  
      <packaging>war</packaging>  
      <version>1.0.0</version>  
      <name>Spring4MVCCRUDRestService Maven Webapp</name>  
       
        <properties>  
            <springframework.version>4.2.0.RELEASE</springframework.version>  
            <jackson.version>2.5.3</jackson.version>  
        </properties>  
       
        <dependencies>  
            <dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-webmvc</artifactId>  
                <version>${springframework.version}</version>  
            </dependency>  
            <dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-tx</artifactId>  
                <version>${springframework.version}</version>  
            </dependency>  
       
            <dependency>  
                <groupId>com.fasterxml.jackson.core</groupId>  
                <artifactId>jackson-databind</artifactId>  
                <version>${jackson.version}</version>  
            </dependency>  
            <dependency>  
                <groupId>javax.servlet</groupId>  
                <artifactId>javax.servlet-api</artifactId>  
                <version>3.1.0</version>  
            </dependency>  
                   
        </dependencies>  
       
       
        <build>  
            <pluginManagement>  
                <plugins>  
                    <plugin>  
                        <groupId>org.apache.maven.plugins</groupId>  
                        <artifactId>maven-compiler-plugin</artifactId>  
                        <version>3.2</version>  
                        <configuration>  
                            <source>1.7</source>  
                            <target>1.7</target>  
                        </configuration>  
                    </plugin>  
                    <plugin>  
                        <groupId>org.apache.maven.plugins</groupId>  
                        <artifactId>maven-war-plugin</artifactId>  
                        <version>2.4</version>  
                        <configuration>  
                            <warSourceDirectory>src/main/webapp</warSourceDirectory>  
                            <warName>Spring4MVCCRUDRestService</warName>  
                            <failOnMissingWebXml>false</failOnMissingWebXml>  
                        </configuration>  
                    </plugin>  
                </plugins>  
            </pluginManagement>  
       
            <finalName>Spring4MVCCRUDRestService</finalName>  
        </build>  
    </project>

3、User Service

package com.websystique.springmvc.service;  
       
    import java.util.List;  
       
    import com.websystique.springmvc.model.User;  
       
       
       
    public interface UserService {  
           
        User findById(long id);  
           
        User findByName(String name);  
           
        void saveUser(User user);  
           
        void updateUser(User user);  
           
        void deleteUserById(long id);  
       
        List<User> findAllUsers();   
           
        void deleteAllUsers();  
           
        public boolean isUserExist(User user);  
           
    }
package com.websystique.springmvc.service;  
       
    import java.util.ArrayList;  
    import java.util.Iterator;  
    import java.util.List;  
    import java.util.concurrent.atomic.AtomicLong;  
       
    import org.springframework.stereotype.Service;  
    import org.springframework.transaction.annotation.Transactional;  
       
    import com.websystique.springmvc.model.User;  
       
    @Service("userService")  
    @Transactional  
    public class UserServiceImpl implements UserService{  
           
        private static final AtomicLong counter = new AtomicLong();  
           
        private static List<User> users;  
           
        static{  
            users= populateDummyUsers();  
        }  
       
        public List<User> findAllUsers() {  
            return users;  
        }  
           
        public User findById(long id) {  
            for(User user : users){  
                if(user.getId() == id){  
                    return user;  
                }  
            }  
            return null;  
        }  
           
        public User findByName(String name) {  
            for(User user : users){  
                if(user.getName().equalsIgnoreCase(name)){  
                    return user;  
                }  
            }  
            return null;  
        }  
           
        public void saveUser(User user) {  
            user.setId(counter.incrementAndGet());  
            users.add(user);  
        }  
       
        public void updateUser(User user) {  
            int index = users.indexOf(user);  
            users.set(index, user);  
        }  
       
        public void deleteUserById(long id) {  
               
            for (Iterator<User> iterator = users.iterator(); iterator.hasNext(); ) {  
                User user = iterator.next();  
                if (user.getId() == id) {  
                    iterator.remove();  
                }  
            }  
        }  
       
        public boolean isUserExist(User user) {  
            return findByName(user.getName())!=null;  
        }  
       
        private static List<User> populateDummyUsers(){  
            List<User> users = new ArrayList<User>();  
            users.add(new User(counter.incrementAndGet(),"Sam",30, 70000));  
            users.add(new User(counter.incrementAndGet(),"Tom",40, 50000));  
            users.add(new User(counter.incrementAndGet(),"Jerome",45, 30000));  
            users.add(new User(counter.incrementAndGet(),"Silvia",50, 40000));  
            return users;  
        }  
       
        public void deleteAllUsers() {  
            users.clear();  
        }  
       
    }

4、Model （模型）类

package com.websystique.springmvc.model;  
       
    public class User {  
       
        private long id;  
           
        private String name;  
           
        private int age;  
           
        private double salary;  
       
        public User(){  
            id=0;  
        }  
           
        public User(long id, String name, int age, double salary){  
            this.id = id;  
            this.name = name;  
            this.age = age;  
            this.salary = salary;  
        }  
           
        public long getId() {  
            return id;  
        }  
       
        public void setId(long 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 double getSalary() {  
            return salary;  
        }  
       
        public void setSalary(double salary) {  
            this.salary = salary;  
        }  
       
        @Override  
        public int hashCode() {  
            final int prime = 31;  
            int result = 1;  
            result = prime * result + (int) (id ^ (id >>> 32));  
            return result;  
        }  
       
        @Override  
        public boolean equals(Object obj) {  
            if (this == obj)  
                return true;  
            if (obj == null)  
                return false;  
            if (getClass() != obj.getClass())  
                return false;  
            User other = (User) obj;  
            if (id != other.id)  
                return false;  
            return true;  
        }  
       
        @Override  
        public String toString() {  
            return "User [id=" + id + ", name=" + name + ", age=" + age  
                    + ", salary=" + salary + "]";  
        }  
       
       
    }

5、配置类

**注意：**下面的配置相当于 applicationContext-springmvc.xml 的配置文件，这只是用java类的方式对 springmvc 配置，这是省配置的方法。 

package com.websystique.springmvc.configuration;  
       
    import org.springframework.context.annotation.ComponentScan;  
    import org.springframework.context.annotation.Configuration;  
    import org.springframework.web.servlet.config.annotation.EnableWebMvc;  
       
    @Configuration  
    @EnableWebMvc  
    @ComponentScan(basePackages = "com.websystique.springmvc")  
    public class HelloWorldConfiguration {  
           
       
    }

由于 restful 的方式不需要视图的配置，所以不需要任何的实现。

6、初始化类（相当于web.xml文件）

**注意：**这个初始化类相当于web.xml文件，这样就省去了 web.xml 的配置。 

package com.websystique.springmvc.configuration;  
       
    import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;  
       
    public class HelloWorldInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {  
        
        @Override  
        protected Class<?>[] getRootConfigClasses() {  
            return new Class[] { HelloWorldConfiguration.class };  
        }  
         
        @Override  
        protected Class<?>[] getServletConfigClasses() {  
            return null;  
        }  
         
        @Override  
        protected String[] getServletMappings() {  
            return new String[] { "/" };  
        }  
        
    }

五、REST API添加CORS支持(实现跨域访问)

当访问REST API时，你可能需要面对“同源策略”问题。

错误如下：

” No ‘Access-Control-Allow-Origin’ header is present on the requested resource. Origin ‘http://127.0.0.1:8080′ is therefore not allowed access.” OR ” XMLHttpRequest cannot load http://abc.com/bla. Origin http://localhost:12345 is not allowed by Access-Control-Allow-Origin.”

一般来说，在服务器端，我们在响应中返回额外的CORS访问控制头，实现跨域链接。

用 Spring的话，我么可以写一个简单的过滤器为每个响应添加CORS特征头。

package com.websystique.springmvc.configuration;  
       
    import java.io.IOException;  
       
    import javax.servlet.Filter;  
    import javax.servlet.FilterChain;  
    import javax.servlet.FilterConfig;  
    import javax.servlet.ServletException;  
    import javax.servlet.ServletRequest;  
    import javax.servlet.ServletResponse;  
    import javax.servlet.http.HttpServletResponse;  
       
       
    public class CORSFilter implements Filter {  
       
        public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {  
            System.out.println("Filtering on...........................................................");  
            HttpServletResponse response = (HttpServletResponse) res;  
            response.setHeader("Access-Control-Allow-Origin", "*");  
            response.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, DELETE");  
            response.setHeader("Access-Control-Max-Age", "3600");  
            response.setHeader("Access-Control-Allow-Headers", "x-requested-with");  
            chain.doFilter(req, res);  
        }  
       
        public void init(FilterConfig filterConfig) {}  
       
        public void destroy() {}  
       
    }

需要将其添加在Spring 配置中：

package com.websystique.springmvc.configuration;  
       
    import javax.servlet.Filter;  
       
    import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;  
       
    public class HelloWorldInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {  
        
        @Override  
        protected Class<?>[] getRootConfigClasses() {  
            return new Class[] { HelloWorldConfiguration.class };  
        }  
         
        @Override  
        protected Class<?>[] getServletConfigClasses() {  
            return null;  
        }  
         
        @Override  
        protected String[] getServletMappings() {  
            return new String[] { "/" };  
        }  
           
        @Override  
        protected Filter[] getServletFilters() {  
            Filter [] singleton = { new CORSFilter()};  
            return singleton;  
        }  
        
    }

  • 源码下载：http://websystique.com/?smd_process_download=1&download_id=1689

  • 源码（带CORS）下载：http://websystique.com/?smd_process_download=1&download_id=1890

参考资料

  • https://blog.csdn.net/w605283073/article/details/51338765#commentsedit
  • https://blog.csdn.net/bhuds/article/details/73865745
  • http://www.ruanyifeng.com/blog/2011/09/restful.html
  • http://www.ruanyifeng.com/blog/2014/05/restful_api.html
  • http://blog.jobbole.com/41233/

文章有不当之处，欢迎指正，你也可以关注我的微信公众号： 好好学java ，获取优质学习资源。

原文  https://juejin.im/post/5b1ddbc96fb9a01e5e3d3f79
正文到此结束
所属分类： Spring

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Java设计模式 Jenkins进阶系列 openfire参考指南 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 ANTLR教程 Ant教程 java实例教程 SpringCloud Elastic-Job-Lite XStream教程 深入浅出MyBatis Hazelcast教程 ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 springcloud-demo JPA教程 ActiveMQ中文指南 Java内存模型 java-demo dubbo教程 Linux入门视频教程
近期评论
  1. 1 Spring Cloud Circuit Breaker快速入门Demo
  2. 2 Spring Cloud Bus快速入门Demo
  3. 3 Spring Cloud Config快速入门Demo
  4. 4 Spring Cloud Function快速入门Demo
  5. 5 SSPanel-Uim搭建教程 2023年全新定制版主题-解决老版本命令失效问题
  6. 6 Spring Boot集成Milvus和deeplearning4j实现图搜图功能
  7. 7 Spring Boot集成Aviator实现参数校验
  8. 8 ACME自动申请免费的通配符https域名证书
  9. 9 wordpress 数据库和文件优化
  10. 10 CentOS安装Docker与Docker-Compose
网站信息
  • 文章总数：82,696 篇
  • 文件总数：284,257 个
  • 标签总数：2,380 个
  • 分类总数：84 个
  • 留言数量：2,560 条
  • 在线人数：661 人
  • 运行天数：4,392天
  • 最后更新：2024年11月05日20点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG