SpringMVC+RestFul詳細示例實戰教程（實現跨域訪問）

程式設計師歐陽思海發表於2018-06-11

一、理解 REST

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 資源：

控制器可以處理所有的 HTTP 方法，包含幾個主要的 REST 方法：GET、POST、PUT、DELETE、PATCH；
藉助 spring 的檢視解析器，資源能夠以多種方式進行表述，包括將模型資料渲染為 XML、JSON、Atom、已經 RSS 的 View 實現；
可以使用 ContentNegotiatingViewResolver 來選擇最適合客戶端的表述；
藉助 @ResponseBody 註解和各種 HttpMethodConverter 實現，能夠替換基於檢視的渲染方式；
類似地，@RequestBody 註解以及 HttpMethodConverter 實現可以將傳入的 HTTP 資料轉化為傳入控制器處理方法的 Java 物件；
藉助 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
這裡寫圖片描述

注意：我們沒有指明任何HTTP頭。點選傳送，將接收到所有使用者的列表
這裡寫圖片描述

也要注意HTTP 200 響應。
這裡寫圖片描述

你也許好奇為什麼此響應通過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
這裡寫圖片描述

現在試著傳送一個帶有錯誤識別碼的GET請求，將收到一個HTTP 404
這裡寫圖片描述

3.建立一個 User

選擇POST方法，指明uri /user/ 指明POSTMAN Body選項卡，選擇application/json型別
這裡寫圖片描述
你要注意POSTMAN自動新增了Content-Type 頭資訊

記住： Accept header包含client能給識別的型別。 Content-Type header表示資料的實際型別。

點選傳送以後將收到 HTTP 200 沒有響應體（api裡面沒有在響應體傳送任何東西）
這裡寫圖片描述

你可以查詢新建立的使用者
這裡寫圖片描述

這是實現REST的普通實現方式。但是也沒人阻止你為POST或者PUT方式響應體裡傳送內容。但是這還是REST 的API？值得懷疑。
不管怎樣，我們試著建立同一個使用者時，你將獲得HTTP衝突的響應。
這裡寫圖片描述

4.更新使用者

傳送一個HTTP PUT 請求來更新使用者。
這裡寫圖片描述
注意：這次我們接收到了響應體。這是因為在控制器的方法實現裡我們傳送了資料。再次強調，有的人也許不在響應體裡面傳送更新的詳情，只傳送位置頭（和建立使用者一樣）。

5.刪除使用者

這裡寫圖片描述

6 刪除所有使用者

這裡寫圖片描述

7.刪除使用者後驗證

這裡寫圖片描述

六、根據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, Cla***esponseType, 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、專案結構

這裡寫圖片描述

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

參考資料

最後傳播一個好訊息，雲端計算已白菜價，雲伺服器低至不到300元/年。這裡有一份雲端計算優惠活動列表，來不及解釋了，趕緊上車！

轉自：http://blog.51cto.com/sihai/2127929

史上最全最強SpringMVC詳細示例實戰教程
2024-04-09
SpringMVC
JavaScript 跨域訪問(API介面)實現原理分析
2019-09-04
JavaScript跨域API
實戰前端跨域問題
2019-04-11
前端跨域
什麼是瀏覽器跨域訪問操作？JS如何實現？
2020-11-09
瀏覽器跨域JS
localStorage 跨域訪問
2019-02-24
跨域
SQL Server跨庫跨伺服器訪問實現
2019-06-19
SQLServer伺服器
跨源通訊、跨域訪問
2020-05-03
跨域
ASP.NET MVC & WebApi 中實現Cors來讓Ajax可以跨域訪問
2018-07-10
ASP.NETMVCWebAPICORS跨域
iframe 元素跨域訪問
2019-07-23
跨域
同源策略和跨域訪問
2018-05-28
跨域
九種方式實現跨域
2019-02-26
跨域
Nginx反向代理實現跨域
2018-12-13
Nginx跨域
JSONP 跨域原理及實現
2022-06-07
JSON跨域
Laravel API 允許跨域訪問
2019-02-16
LaravelAPI跨域
詳解瀏覽器跨域訪問的幾種辦法
2021-06-04
瀏覽器跨域
解決JS跨域訪問的問題
2024-06-22
JS跨域
內網IP地址實現HTTPS加密訪問教程
2024-11-11
內網HTTP加密
跨域方案總結與實現
2019-04-15
跨域
多種跨域方式實現原理
2018-09-29
跨域
九種跨域方式實現原理
2019-02-02
跨域
kubernetes實戰篇之helm示例yaml檔案檔案詳細介紹
2019-07-06
YAML
Iframe嵌入跨域頁面高度自適應實現詳解
2020-12-02
跨域
解決uniapp h5 本地代理實現跨域訪問及如何配置開發環境
2024-06-21
APPH5跨域開發環境
【SpringBoot實戰】資料訪問
2022-04-05
Spring Boot
Nginx 實現動態封禁IP，詳細教程來了
2024-10-25
Nginx
非面試向跨域實踐詳解
2018-09-11
面試跨域
vue_cli3.x 跨域訪問
2019-05-22
Vue跨域
springboot配置CORS允許跨域訪問
2018-12-21
Spring BootCORS跨域
spring boot解決跨域訪問配置
2020-12-07
Spring Boot跨域
Gin與Mysql實現簡單Restful風格API實戰示例詳解PRHC
2022-03-01
MySqlRESTAPI
防止跨域問題無法訪問網址
2024-03-19
跨域
vue---axios實現資料互動與跨域問題
2019-05-11
VueiOS跨域
專案實戰之跨域處理~一文搞定所有跨域需求
2020-07-31
跨域
CORS方式實現ajax跨域 — nginx配置
2019-01-19
CORS跨域Nginx
Ajax+SpringMVC實現跨域請求
2018-08-10
SpringMVC跨域
Laravel + JWT 實現 API 跨域授權
2018-06-30
LaravelJWTAPI跨域
Spring Boot 通過CORS實現跨域
2020-09-01
Spring BootCORS跨域
jquery 之 jsonp 與 laravel 實現跨域
2020-10-13
jQueryJSONLaravel跨域

SpringMVC+RestFul詳細示例實戰教程（實現跨域訪問）

一、理解 REST

二、使用 RESTful 架構設計使用誤區

三、 springMVC 支援 RESTful

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

springmvc註解詳解

五、釋出和測試此API

1. 獲取所有使用者

2. 獲取單個使用者

3.建立一個 User

4.更新使用者

5.刪除使用者

6 刪除所有使用者

7.刪除使用者後驗證

六、根據RestTemplate 寫REST Client

定義 Rest client , 定義REST services

七、完整的例子

1、專案結構

2、pom.xml新增專案依賴

3、User Service

4、Model （模型）類

5、配置類

6、初始化類（相當於web.xml檔案）

五、REST API新增CORS支援(實現跨域訪問)

最後傳播一個好訊息，雲端計算已白菜價，雲伺服器低至不到300元/年。這裡有一份雲端計算優惠活動列表，來不及解釋了，趕緊上車！

相關文章