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

最新推荐文章于 2021-11-16 03:21:47 发布

weixin_45121123

最新推荐文章于 2021-11-16 03:21:47 发布

阅读量151

点赞数

原文链接：https://blog.51cto.com/sihai/2127929

版权

一、理解 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这个外部客户端，接下来我们也将写我们自己的客户端。

获取所有用户
打开 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注解。

获取单个用户
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添加项目依赖

4.0.0
com.websystique.springmvc
Spring4MVCCRUDRestService
war
1.0.0
Spring4MVCCRUDRestService Maven Webapp

    <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;  
    }  

}  
www.yisuping.com