REST API 開發

時間  2019-11-11
標籤 rest api 開發 简体版
原文   原文鏈接

本文咱們將使用Spring MVC 4實現 CRUD Restful WebService , 經過RestTemplate寫一個 REST 客戶端，定義這些服務. 咱們也能夠經過外部的一些客戶端來測試這些服務。html

 

 

簡短 & 快速介紹REST

REST表示 Representational State Transfer（表示性狀態轉換）.java

 

它是能夠用來設計web services的框架，能夠被不一樣的客戶端調用。web

核心思想是：使用簡單的HTTP協議來實現調用，而不是CORBA, RPC 或者 SOAP等負責的機制。spring

 

在Rest 基礎設計中，資源使用如下動詞進行操做。apache

 

  • 建立資源 : 使用 HTTP POST
  • 獲取資源 : 使用 HTTP GET
  • 更新資源 : 使用 HTTP PUT 
  • 刪除資源 : 使用 HTTP DELETE 

也意味着,你做爲Rest 服務開發者或者客戶，應該遵循以上的標準。json

 

 

儘管沒有限制必須返回的類型，可是通常基於Web services的Rest返回JSON或者XML做爲響應。api

 

客戶端能夠指定（使用HTTP Accept header）他們想要的資源類型嗎，服務器返回須要的資源。跨域

指明資源的Content-Type。若是想詳細的理解 restful能夠參考這裏：StackOverflow link 服務器

 

 

基於Rest的Controller（控制器）

咱們的 REST API :restful

  • 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
[java]  view plain  copy
 
 
 
  1. package com.websystique.springmvc.controller;  
  2.    
  3. import java.util.List;  
  4.    
  5. import org.springframework.beans.factory.annotation.Autowired;  
  6. import org.springframework.http.HttpHeaders;  
  7. import org.springframework.http.HttpStatus;  
  8. import org.springframework.http.MediaType;  
  9. import org.springframework.http.ResponseEntity;  
  10. import org.springframework.web.bind.annotation.PathVariable;  
  11. import org.springframework.web.bind.annotation.RequestBody;  
  12. import org.springframework.web.bind.annotation.RequestMapping;  
  13. import org.springframework.web.bind.annotation.RequestMethod;  
  14. import org.springframework.web.bind.annotation.RestController;  
  15. import org.springframework.web.util.UriComponentsBuilder;  
  16.    
  17. import com.websystique.springmvc.model.User;  
  18. import com.websystique.springmvc.service.UserService;  
  19.    
  20. @RestController  
  21. public class HelloWorldRestController {  
  22.    
  23.     @Autowired  
  24.     UserService userService;  //Service which will do all data retrieval/manipulation work  
  25.    
  26.        
  27.     //-------------------Retrieve All Users--------------------------------------------------------  
  28.        
  29.     @RequestMapping(value = "/user/", method = RequestMethod.GET)  
  30.     public ResponseEntity<List<User>> listAllUsers() {  
  31.         List<User> users = userService.findAllUsers();  
  32.         if(users.isEmpty()){  
  33.             return new ResponseEntity<List<User>>(HttpStatus.NO_CONTENT);//You many decide to return HttpStatus.NOT_FOUND  
  34.         }  
  35.         return new ResponseEntity<List<User>>(users, HttpStatus.OK);  
  36.     }  
  37.    
  38.    
  39.     //-------------------Retrieve Single User--------------------------------------------------------  
  40.        
  41.     @RequestMapping(value = "/user/{id}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)  
  42.     public ResponseEntity<User> getUser(@PathVariable("id") long id) {  
  43.         System.out.println("Fetching User with id " + id);  
  44.         User user = userService.findById(id);  
  45.         if (user == null) {  
  46.             System.out.println("User with id " + id + " not found");  
  47.             return new ResponseEntity<User>(HttpStatus.NOT_FOUND);  
  48.         }  
  49.         return new ResponseEntity<User>(user, HttpStatus.OK);  
  50.     }  
  51.    
  52.        
  53.        
  54.     //-------------------Create a User--------------------------------------------------------  
  55.        
  56.     @RequestMapping(value = "/user/", method = RequestMethod.POST)  
  57.     public ResponseEntity<Void> createUser(@RequestBody User user,    UriComponentsBuilder ucBuilder) {  
  58.         System.out.println("Creating User " + user.getName());  
  59.    
  60.         if (userService.isUserExist(user)) {  
  61.             System.out.println("A User with name " + user.getName() + " already exist");  
  62.             return new ResponseEntity<Void>(HttpStatus.CONFLICT);  
  63.         }  
  64.    
  65.         userService.saveUser(user);  
  66.    
  67.         HttpHeaders headers = new HttpHeaders();  
  68.         headers.setLocation(ucBuilder.path("/user/{id}").buildAndExpand(user.getId()).toUri());  
  69.         return new ResponseEntity<Void>(headers, HttpStatus.CREATED);  
  70.     }  
  71.    
  72.        
  73.     //------------------- Update a User --------------------------------------------------------  
  74.        
  75.     @RequestMapping(value = "/user/{id}", method = RequestMethod.PUT)  
  76.     public ResponseEntity<User> updateUser(@PathVariable("id") long id, @RequestBody User user) {  
  77.         System.out.println("Updating User " + id);  
  78.            
  79.         User currentUser = userService.findById(id);  
  80.            
  81.         if (currentUser==null) {  
  82.             System.out.println("User with id " + id + " not found");  
  83.             return new ResponseEntity<User>(HttpStatus.NOT_FOUND);  
  84.         }  
  85.    
  86.         currentUser.setName(user.getName());  
  87.         currentUser.setAge(user.getAge());  
  88.         currentUser.setSalary(user.getSalary());  
  89.            
  90.         userService.updateUser(currentUser);  
  91.         return new ResponseEntity<User>(currentUser, HttpStatus.OK);  
  92.     }  
  93.    
  94.     //------------------- Delete a User --------------------------------------------------------  
  95.        
  96.     @RequestMapping(value = "/user/{id}", method = RequestMethod.DELETE)  
  97.     public ResponseEntity<User> deleteUser(@PathVariable("id") long id) {  
  98.         System.out.println("Fetching & Deleting User with id " + id);  
  99.    
  100.         User user = userService.findById(id);  
  101.         if (user == null) {  
  102.             System.out.println("Unable to delete. User with id " + id + " not found");  
  103.             return new ResponseEntity<User>(HttpStatus.NOT_FOUND);  
  104.         }  
  105.    
  106.         userService.deleteUserById(id);  
  107.         return new ResponseEntity<User>(HttpStatus.NO_CONTENT);  
  108.     }  
  109.    
  110.        
  111.     //------------------- Delete All Users --------------------------------------------------------  
  112.        
  113.     @RequestMapping(value = "/user/", method = RequestMethod.DELETE)  
  114.     public ResponseEntity<User> deleteAllUsers() {  
  115.         System.out.println("Deleting All Users");  
  116.    
  117.         userService.deleteAllUsers();  
  118.         return new ResponseEntity<User>(HttpStatus.NO_CONTENT);  
  119.     }  
  120.    
  121. }  

詳解：

@RestController :首先咱們使用的是Spring 4的新註解 @RestController註解. 

此註解避免了每一個方法都要加上@ResponseBody註解。也就是說@RestController 本身戴上了 @ResponseBody註解,看以看做是

 @Controller 和 @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

 http://localhost:8080/Spring4MVCCRUDRestService.
 
想要測試此API，我將使用POSTMAN這個外部客戶端，接下來咱們也將寫咱們本身的客戶端。
1. 獲取全部用戶
 
打開 POSTMAN工具，選擇請求類型爲GET，指明uri
 
注意：咱們沒有指明任何HTTP頭。點擊 發送，將接收到全部用戶的列表
 
 
也要注意HTTP 200 響應。
 
你也許好奇爲何此響應經過JSON字符串發送的，在響應裏的Content-Type 頭說明了這個。
由於咱們添加了JACKSON
[html]  view plain  copy
 
 
 
  1. <dependency>  
  2.     <groupId>com.fasterxml.jackson.core</groupId>  
  3.     <artifactId>jackson-databind</artifactId>  
  4.     <version>2.5.3</version>  
  5. </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, 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 
[java]  view plain  copy
 
 
 
  1. package com.websystique.springmvc;  
  2.    
  3. import java.net.URI;  
  4. import java.util.LinkedHashMap;  
  5. import java.util.List;  
  6.    
  7. import org.springframework.web.client.RestTemplate;  
  8.    
  9. import com.websystique.springmvc.model.User;  
  10.    
  11. public class SpringRestTestClient {  
  12.    
  13.     public static final String REST_SERVICE_URI = "http://localhost:8080/Spring4MVCCRUDRestService";  
  14.        
  15.     /* GET */  
  16.     @SuppressWarnings("unchecked")  
  17.     private static void listAllUsers(){  
  18.         System.out.println("Testing listAllUsers API-----------");  
  19.            
  20.         RestTemplate restTemplate = new RestTemplate();  
  21.         List<LinkedHashMap<String, Object>> usersMap = restTemplate.getForObject(REST_SERVICE_URI+"/user/", List.class);  
  22.            
  23.         if(usersMap!=null){  
  24.             for(LinkedHashMap<String, Object> map : usersMap){  
  25.                 System.out.println("User : id="+map.get("id")+", Name="+map.get("name")+", Age="+map.get("age")+", Salary="+map.get("salary"));;  
  26.             }  
  27.         }else{  
  28.             System.out.println("No user exist----------");  
  29.         }  
  30.     }  
  31.        
  32.     /* GET */  
  33.     private static void getUser(){  
  34.         System.out.println("Testing getUser API----------");  
  35.         RestTemplate restTemplate = new RestTemplate();  
  36.         User user = restTemplate.getForObject(REST_SERVICE_URI+"/user/1", User.class);  
  37.         System.out.println(user);  
  38.     }  
  39.        
  40.     /* POST */  
  41.     private static void createUser() {  
  42.         System.out.println("Testing create User API----------");  
  43.         RestTemplate restTemplate = new RestTemplate();  
  44.         User user = new User(0,"Sarah",51,134);  
  45.         URI uri = restTemplate.postForLocation(REST_SERVICE_URI+"/user/", user, User.class);  
  46.         System.out.println("Location : "+uri.toASCIIString());  
  47.     }  
  48.    
  49.     /* PUT */  
  50.     private static void updateUser() {  
  51.         System.out.println("Testing update User API----------");  
  52.         RestTemplate restTemplate = new RestTemplate();  
  53.         User user  = new User(1,"Tomy",33, 70000);  
  54.         restTemplate.put(REST_SERVICE_URI+"/user/1", user);  
  55.         System.out.println(user);  
  56.     }  
  57.    
  58.     /* DELETE */  
  59.     private static void deleteUser() {  
  60.         System.out.println("Testing delete User API----------");  
  61.         RestTemplate restTemplate = new RestTemplate();  
  62.         restTemplate.delete(REST_SERVICE_URI+"/user/3");  
  63.     }  
  64.    
  65.    
  66.     /* DELETE */  
  67.     private static void deleteAllUsers() {  
  68.         System.out.println("Testing all delete Users API----------");  
  69.         RestTemplate restTemplate = new RestTemplate();  
  70.         restTemplate.delete(REST_SERVICE_URI+"/user/");  
  71.     }  
  72.    
  73.     public static void main(String args[]){  
  74.         listAllUsers();  
  75.         getUser();  
  76.         createUser();  
  77.         listAllUsers();  
  78.         updateUser();  
  79.         listAllUsers();  
  80.         deleteUser();  
  81.         listAllUsers();  
  82.         deleteAllUsers();  
  83.         listAllUsers();  
  84.     }  
  85. }  

重啓服務器，運行上面的程序。
下面是輸出：
[plain]  view plain  copy
 
 
 
  1. Testing listAllUsers API-----------  
  2. User : id=1, Name=Sam, Age=30, Salary=70000.0  
  3. User : id=2, Name=Tom, Age=40, Salary=50000.0  
  4. User : id=3, Name=Jerome, Age=45, Salary=30000.0  
  5. User : id=4, Name=Silvia, Age=50, Salary=40000.0  
  6. Testing getUser API----------  
  7. User [id=1, name=Sam, age=30, salary=70000.0]  
  8. Testing create User API----------  
  9. Location : http://localhost:8080/Spring4MVCCRUDRestService/user/5  
  10. Testing listAllUsers API-----------  
  11. User : id=1, Name=Sam, Age=30, Salary=70000.0  
  12. User : id=2, Name=Tom, Age=40, Salary=50000.0  
  13. User : id=3, Name=Jerome, Age=45, Salary=30000.0  
  14. User : id=4, Name=Silvia, Age=50, Salary=40000.0  
  15. User : id=5, Name=Sarah, Age=51, Salary=134.0  
  16. Testing update User API----------  
  17. User [id=1, name=Tomy, age=33, salary=70000.0]  
  18. Testing listAllUsers API-----------  
  19. User : id=1, Name=Tomy, Age=33, Salary=70000.0  
  20. User : id=2, Name=Tom, Age=40, Salary=50000.0  
  21. User : id=3, Name=Jerome, Age=45, Salary=30000.0  
  22. User : id=4, Name=Silvia, Age=50, Salary=40000.0  
  23. User : id=5, Name=Sarah, Age=51, Salary=134.0  
  24. Testing delete User API----------  
  25. Testing listAllUsers API-----------  
  26. User : id=1, Name=Tomy, Age=33, Salary=70000.0  
  27. User : id=2, Name=Tom, Age=40, Salary=50000.0  
  28. User : id=4, Name=Silvia, Age=50, Salary=40000.0  
  29. User : id=5, Name=Sarah, Age=51, Salary=134.0  
  30. Testing all delete Users API----------  
  31. Testing listAllUsers API-----------  
  32. No user exist----------  

完整的例子
 

更新pom.xml添加項目依賴

[html]  view plain  copy
 
 
 
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   <groupId>com.websystique.springmvc</groupId>  
  5.   <artifactId>Spring4MVCCRUDRestService</artifactId>  
  6.   <packaging>war</packaging>  
  7.   <version>1.0.0</version>  
  8.   <name>Spring4MVCCRUDRestService Maven Webapp</name>  
  9.    
  10.     <properties>  
  11.         <springframework.version>4.2.0.RELEASE</springframework.version>  
  12.         <jackson.version>2.5.3</jackson.version>  
  13.     </properties>  
  14.    
  15.     <dependencies>  
  16.         <dependency>  
  17.             <groupId>org.springframework</groupId>  
  18.             <artifactId>spring-webmvc</artifactId>  
  19.             <version>${springframework.version}</version>  
  20.         </dependency>  
  21.         <dependency>  
  22.             <groupId>org.springframework</groupId>  
  23.             <artifactId>spring-tx</artifactId>  
  24.             <version>${springframework.version}</version>  
  25.         </dependency>  
  26.    
  27.         <dependency>  
  28.             <groupId>com.fasterxml.jackson.core</groupId>  
  29.             <artifactId>jackson-databind</artifactId>  
  30.             <version>${jackson.version}</version>  
  31.         </dependency>  
  32.         <dependency>  
  33.             <groupId>javax.servlet</groupId>  
  34.             <artifactId>javax.servlet-api</artifactId>  
  35.             <version>3.1.0</version>  
  36.         </dependency>  
  37.                
  38.     </dependencies>  
  39.    
  40.    
  41.     <build>  
  42.         <pluginManagement>  
  43.             <plugins>  
  44.                 <plugin>  
  45.                     <groupId>org.apache.maven.plugins</groupId>  
  46.                     <artifactId>maven-compiler-plugin</artifactId>  
  47.                     <version>3.2</version>  
  48.                     <configuration>  
  49.                         <source>1.7</source>  
  50.                         <target>1.7</target>  
  51.                     </configuration>  
  52.                 </plugin>  
  53.                 <plugin>  
  54.                     <groupId>org.apache.maven.plugins</groupId>  
  55.                     <artifactId>maven-war-plugin</artifactId>  
  56.                     <version>2.4</version>  
  57.                     <configuration>  
  58.                         <warSourceDirectory>src/main/webapp</warSourceDirectory>  
  59.                         <warName>Spring4MVCCRUDRestService</warName>  
  60.                         <failOnMissingWebXml>false</failOnMissingWebXml>  
  61.                     </configuration>  
  62.                 </plugin>  
  63.             </plugins>  
  64.         </pluginManagement>  
  65.    
  66.         <finalName>Spring4MVCCRUDRestService</finalName>  
  67.     </build>  
  68. </project>  

User Service

[java]  view plain  copy
 
 
 
  1. package com.websystique.springmvc.service;  
  2.    
  3. import java.util.List;  
  4.    
  5. import com.websystique.springmvc.model.User;  
  6.    
  7.    
  8.    
  9. public interface UserService {  
  10.        
  11.     User findById(long id);  
  12.        
  13.     User findByName(String name);  
  14.        
  15.     void saveUser(User user);  
  16.        
  17.     void updateUser(User user);  
  18.        
  19.     void deleteUserById(long id);  
  20.    
  21.     List<User> findAllUsers();   
  22.        
  23.     void deleteAllUsers();  
  24.        
  25.     public boolean isUserExist(User user);  
  26.        
  27. }  


[java]  view plain  copy
 
 
 
  1. package com.websystique.springmvc.service;  
  2.    
  3. import java.util.ArrayList;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6. import java.util.concurrent.atomic.AtomicLong;  
  7.    
  8. import org.springframework.stereotype.Service;  
  9. import org.springframework.transaction.annotation.Transactional;  
  10.    
  11. import com.websystique.springmvc.model.User;  
  12.    
  13. @Service("userService")  
  14. @Transactional  
  15. public class UserServiceImpl implements UserService{  
  16.        
  17.     private static final AtomicLong counter = new AtomicLong();  
  18.        
  19.     private static List<User> users;  
  20.        
  21.     static{  
  22.         users= populateDummyUsers();  
  23.     }  
  24.    
  25.     public List<User> findAllUsers() {  
  26.         return users;  
  27.     }  
  28.        
  29.     public User findById(long id) {  
  30.         for(User user : users){  
  31.             if(user.getId() == id){  
  32.                 return user;  
  33.             }  
  34.         }  
  35.         return null;  
  36.     }  
  37.        
  38.     public User findByName(String name) {  
  39.         for(User user : users){  
  40.             if(user.getName().equalsIgnoreCase(name)){  
  41.                 return user;  
  42.             }  
  43.         }  
  44.         return null;  
  45.     }  
  46.        
  47.     public void saveUser(User user) {  
  48.         user.setId(counter.incrementAndGet());  
  49.         users.add(user);  
  50.     }  
  51.    
  52.     public void updateUser(User user) {  
  53.         int index = users.indexOf(user);  
  54.         users.set(index, user);  
  55.     }  
  56.    
  57.     public void deleteUserById(long id) {  
  58.            
  59.         for (Iterator<User> iterator = users.iterator(); iterator.hasNext(); ) {  
  60.             User user = iterator.next();  
  61.             if (user.getId() == id) {  
  62.                 iterator.remove();  
  63.             }  
  64.         }  
  65.     }  
  66.    
  67.     public boolean isUserExist(User user) {  
  68.         return findByName(user.getName())!=null;  
  69.     }  
  70.    
  71.     private static List<User> populateDummyUsers(){  
  72.         List<User> users = new ArrayList<User>();  
  73.         users.add(new User(counter.incrementAndGet(),"Sam",30, 70000));  
  74.         users.add(new User(counter.incrementAndGet(),"Tom",40, 50000));  
  75.         users.add(new User(counter.incrementAndGet(),"Jerome",45, 30000));  
  76.         users.add(new User(counter.incrementAndGet(),"Silvia",50, 40000));  
  77.         return users;  
  78.     }  
  79.    
  80.     public void deleteAllUsers() {  
  81.         users.clear();  
  82.     }  
  83.    
  84. }  

Model （模型）類

[java]  view plain  copy
 
 
 
  1. package com.websystique.springmvc.model;  
  2.    
  3. public class User {  
  4.    
  5.     private long id;  
  6.        
  7.     private String name;  
  8.        
  9.     private int age;  
  10.        
  11.     private double salary;  
  12.    
  13.     public User(){  
  14.         id=0;  
  15.     }  
  16.        
  17.     public User(long id, String name, int age, double salary){  
  18.         this.id = id;  
  19.         this.name = name;  
  20.         this.age = age;  
  21.         this.salary = salary;  
  22.     }  
  23.        
  24.     public long getId() {  
  25.         return id;  
  26.     }  
  27.    
  28.     public void setId(long id) {  
  29.         this.id = id;  
  30.     }  
  31.    
  32.     public String getName() {  
  33.         return name;  
  34.     }  
  35.    
  36.     public void setName(String name) {  
  37.         this.name = name;  
  38.     }  
  39.    
  40.     public int getAge() {  
  41.         return age;  
  42.     }  
  43.    
  44.     public void setAge(int age) {  
  45.         this.age = age;  
  46.     }  
  47.    
  48.     public double getSalary() {  
  49.         return salary;  
  50.     }  
  51.    
  52.     public void setSalary(double salary) {  
  53.         this.salary = salary;  
  54.     }  
  55.    
  56.     @Override  
  57.     public int hashCode() {  
  58.         final int prime = 31;  
  59.         int result = 1;  
  60.         result = prime * result + (int) (id ^ (id >>> 32));  
  61.         return result;  
  62.     }  
  63.    
  64.     @Override  
  65.     public boolean equals(Object obj) {  
  66.         if (this == obj)  
  67.             return true;  
  68.         if (obj == null)  
  69.             return false;  
  70.         if (getClass() != obj.getClass())  
  71.             return false;  
  72.         User other = (User) obj;  
  73.         if (id != other.id)  
  74.             return false;  
  75.         return true;  
  76.     }  
  77.    
  78.     @Override  
  79.     public String toString() {  
  80.         return "User [id=" + id + ", name=" + name + ", age=" + age  
  81.                 + ", salary=" + salary + "]";  
  82.     }  
  83.    
  84.    
  85. }  


配置類
[java]  view plain  copy
 
 
 
  1. package com.websystique.springmvc.configuration;  
  2.    
  3. import org.springframework.context.annotation.ComponentScan;  
  4. import org.springframework.context.annotation.Configuration;  
  5. import org.springframework.web.servlet.config.annotation.EnableWebMvc;  
  6.    
  7. @Configuration  
  8. @EnableWebMvc  
  9. @ComponentScan(basePackages = "com.websystique.springmvc")  
  10. public class HelloWorldConfiguration {  
  11.        
  12.    
  13. }  
 
初始化類
[java]  view plain  copy
 
 
 
  1. package com.websystique.springmvc.configuration;  
  2.    
  3. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;  
  4.    
  5. public class HelloWorldInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {  
  6.     
  7.     @Override  
  8.     protected Class<?>[] getRootConfigClasses() {  
  9.         return new Class[] { HelloWorldConfiguration.class };  
  10.     }  
  11.      
  12.     @Override  
  13.     protected Class<?>[] getServletConfigClasses() {  
  14.         return null;  
  15.     }  
  16.      
  17.     @Override  
  18.     protected String[] getServletMappings() {  
  19.         return new String[] { "/" };  
  20.     }  
  21.     
  22. }  


爲你的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特徵頭。
[java]  view plain  copy
 
 
 
  1. package com.websystique.springmvc.configuration;  
  2.    
  3. import java.io.IOException;  
  4.    
  5. import javax.servlet.Filter;  
  6. import javax.servlet.FilterChain;  
  7. import javax.servlet.FilterConfig;  
  8. import javax.servlet.ServletException;  
  9. import javax.servlet.ServletRequest;  
  10. import javax.servlet.ServletResponse;  
  11. import javax.servlet.http.HttpServletResponse;  
  12.    
  13.    
  14. public class CORSFilter implements Filter {  
  15.    
  16.     public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {  
  17.         System.out.println("Filtering on...........................................................");  
  18.         HttpServletResponse response = (HttpServletResponse) res;  
  19.         response.setHeader("Access-Control-Allow-Origin", "*");  
  20.         response.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, DELETE");  
  21.         response.setHeader("Access-Control-Max-Age", "3600");  
  22.         response.setHeader("Access-Control-Allow-Headers", "x-requested-with");  
  23.         chain.doFilter(req, res);  
  24.     }  
  25.    
  26.     public void init(FilterConfig filterConfig) {}  
  27.    
  28.     public void destroy() {}  
  29.    
  30. }  
須要將其添加在Spring 配置中：
[java]  view plain  copy
 
 
 
  1. package com.websystique.springmvc.configuration;  
  2.    
  3. import javax.servlet.Filter;  
  4.    
  5. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;  
  6.    
  7. public class HelloWorldInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {  
  8.     
  9.     @Override  
  10.     protected Class<?>[] getRootConfigClasses() {  
  11.         return new Class[] { HelloWorldConfiguration.class };  
  12.     }  
  13.      
  14.     @Override  
  15.     protected Class<?>[] getServletConfigClasses() {  
  16.         return null;  
  17.     }  
  18.      
  19.     @Override  
  20.     protected String[] getServletMappings() {  
  21.         return new String[] { "/" };  
  22.     }  
  23.        
  24.     @Override  
  25.     protected Filter[] getServletFilters() {  
  26.         Filter [] singleton = { new CORSFilter()};  
  27.         return singleton;  
  28.     }  
  29.     
  30. }  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程