programming

Kiểm soát truy cập cho phép ví dụ nguồn gốc

Hướng dẫn này hướng dẫn bạn quy trình tạo dịch vụ web RESTful “Xin chào, Thế giới” với Spring bao gồm các tiêu đề cho Chia sẻ tài nguyên nguồn gốc chéo [CORS] trong phản hồi. Bạn có thể tìm thêm thông tin về hỗ trợ Spring CORS trong bài đăng trên blog này

Những gì bạn sẽ xây dựng

Bạn sẽ xây dựng một dịch vụ chấp nhận các yêu cầu HTTP GET tại

{"id":1,"content":"Hello, User!"}

6 và phản hồi bằng biểu diễn JSON của lời chào, như danh sách sau đây cho thấy

{"id":1,"content":"Hello, World!"}

Bạn có thể tùy chỉnh lời chào bằng tham số

{"id":1,"content":"Hello, User!"}

7 tùy chọn trong chuỗi truy vấn, như danh sách sau hiển thị

//localhost:8080/greeting?name=User

Giá trị tham số

{"id":1,"content":"Hello, User!"}

7 sẽ ghi đè giá trị mặc định của

{"id":1,"content":"Hello, User!"}

9 và được phản ánh trong phản hồi, như danh sách sau đây cho thấy

{"id":1,"content":"Hello, User!"}

Dịch vụ này hơi khác so với dịch vụ được mô tả trong Xây dựng Dịch vụ web RESTful, ở chỗ nó sử dụng hỗ trợ Spring Framework CORS để thêm các tiêu đề phản hồi CORS có liên quan

Những gì bạn cần

Khoảng 15 phút
Trình soạn thảo văn bản hoặc IDE yêu thích
JDK 1. 8 hoặc muộn hơn
Lớp 4+ hoặc Maven 3. 2+
Bạn cũng có thể nhập thẳng mã vào IDE của mình
- Bộ công cụ mùa xuân [STS]
- Ý TƯỞNG IntelliJ
- VSCode

Làm thế nào để hoàn thành hướng dẫn này

Giống như hầu hết các hướng dẫn Bắt đầu với Spring, bạn có thể bắt đầu từ đầu và hoàn thành từng bước hoặc bạn có thể bỏ qua các bước thiết lập cơ bản đã quen thuộc với bạn. Dù bằng cách nào, bạn sẽ kết thúc với mã làm việc

Để bắt đầu lại từ đầu, hãy chuyển sang phần Bắt đầu với Spring Initializr

Để bỏ qua những điều cơ bản, hãy làm như sau

Tải xuống và giải nén kho lưu trữ nguồn cho hướng dẫn này hoặc sao chép nó bằng Git.
```
  org.apache.httpcomponents
  httpclient
  test
```
0

cd into


  org.apache.httpcomponents
  httpclient
  test

Tiếp tục để tạo một lớp biểu diễn tài nguyên

Khi bạn hoàn thành, bạn có thể kiểm tra kết quả của mình với mã trong


  org.apache.httpcomponents
  httpclient
  test

Bắt đầu với Khởi tạo mùa xuân

Bạn có thể sử dụng dự án được khởi tạo trước này và nhấp vào Tạo để tải xuống tệp ZIP. Dự án này được cấu hình để phù hợp với các ví dụ trong hướng dẫn này

Để khởi tạo dự án theo cách thủ công

Điều hướng đến https. //bắt đầu. mùa xuân. io. Dịch vụ này thu thập tất cả các phụ thuộc bạn cần cho một ứng dụng và thực hiện hầu hết các thiết lập cho bạn
Chọn Gradle hoặc Maven và ngôn ngữ bạn muốn sử dụng. Hướng dẫn này giả định rằng bạn đã chọn Java
Nhấp vào Phụ thuộc và chọn Web mùa xuân
Nhấp vào Tạo
Tải xuống tệp ZIP kết quả, đây là kho lưu trữ ứng dụng web được định cấu hình theo lựa chọn của bạn

Nếu IDE của bạn có tích hợp Spring Initializr, bạn có thể hoàn tất quy trình này từ IDE của mình

Bạn cũng có thể rẽ nhánh dự án từ Github và mở nó trong IDE hoặc trình chỉnh sửa khác của bạn

Thêm phụ thuộc


  org.apache.httpcomponents
  httpclient
  test

Các bài kiểm tra [trong


  org.apache.httpcomponents
  httpclient
  test

4] yêu cầu thư viện Apache


  org.apache.httpcomponents
  httpclient
  test

Để thêm thư viện Apache


  org.apache.httpcomponents
  httpclient
  test

3 vào Maven, hãy thêm phần phụ thuộc sau


  org.apache.httpcomponents
  httpclient
  test

Danh sách sau đây hiển thị tệp


  org.apache.httpcomponents
  httpclient
  test

7 đã hoàn thành

{"id":1,"content":"Hello, World!"}

Để thêm thư viện Apache


  org.apache.httpcomponents
  httpclient
  test

3 vào Gradle, hãy thêm phần phụ thuộc sau

{"id":1,"content":"Hello, World!"}

Danh sách sau đây hiển thị tệp


  org.apache.httpcomponents
  httpclient
  test

9 đã hoàn thành

{"id":1,"content":"Hello, User!"}

Tạo một lớp biểu diễn tài nguyên

Bây giờ bạn đã thiết lập dự án và xây dựng hệ thống, bạn có thể tạo dịch vụ web của mình

Bắt đầu quy trình bằng cách suy nghĩ về các tương tác dịch vụ

Dịch vụ sẽ xử lý các yêu cầu của

{"id":1,"content":"Hello, World!"}

60 đến

{"id":1,"content":"Hello, World!"}

61, tùy chọn với tham số

{"id":1,"content":"Hello, User!"}

7 trong chuỗi truy vấn. Yêu cầu

{"id":1,"content":"Hello, World!"}

60 phải trả về phản hồi

{"id":1,"content":"Hello, World!"}

64 với JSON trong phần nội dung để thể hiện lời chào. Nó sẽ giống như danh sách sau đây

{"id":1,"content":"Hello, User!"}

Trường

{"id":1,"content":"Hello, World!"}

65 là mã định danh duy nhất cho lời chào và

{"id":1,"content":"Hello, World!"}

66 là biểu diễn văn bản của lời chào

Để mô hình hóa biểu diễn lời chào, hãy tạo một lớp biểu diễn tài nguyên. Cung cấp một đối tượng Java cũ đơn giản với các trường, hàm tạo và trình truy cập cho dữ liệu

{"id":1,"content":"Hello, World!"}

65 và

{"id":1,"content":"Hello, World!"}

66, như danh sách sau [từ

{"id":1,"content":"Hello, World!"}

69] cho thấy

//localhost:8080/greeting?name=User

Spring sử dụng thư viện Jackson JSON để tự động sắp xếp các thể hiện của loại

{"id":1,"content":"Hello, World!"}

80 thành JSON

Tạo bộ điều khiển tài nguyên

Trong cách tiếp cận của Spring để xây dựng các dịch vụ web RESTful, các yêu cầu HTTP được xử lý bởi bộ điều khiển. Các thành phần này dễ dàng được xác định bằng chú thích

{"id":1,"content":"Hello, World!"}

81 và

{"id":1,"content":"Hello, World!"}

82 được hiển thị trong danh sách sau [từ

{"id":1,"content":"Hello, World!"}

83] xử lý các yêu cầu của

{"id":1,"content":"Hello, World!"}

60 cho

{"id":1,"content":"Hello, World!"}

61 bằng cách trả về một thể hiện mới của lớp

{"id":1,"content":"Hello, World!"}

{"id":1,"content":"Hello, User!"}

Bộ điều khiển này ngắn gọn và đơn giản, nhưng có rất nhiều thứ đang diễn ra bên trong. Chúng tôi phá vỡ nó từng bước

Chú thích

{"id":1,"content":"Hello, World!"}

87 đảm bảo rằng các yêu cầu HTTP tới

{"id":1,"content":"Hello, World!"}

61 được ánh xạ tới phương thức

{"id":1,"content":"Hello, World!"}

Ví dụ trước sử dụng chú thích

{"id":1,"content":"Hello, User!"}

00, hoạt động như một lối tắt cho

{"id":1,"content":"Hello, User!"}

01. Chúng tôi sử dụng

{"id":1,"content":"Hello, World!"}

60 trong trường hợp này vì nó thuận tiện cho việc kiểm tra. Spring vẫn sẽ từ chối yêu cầu GET khi nguồn gốc không khớp với cấu hình CORS. Trình duyệt không bắt buộc phải gửi yêu cầu trước chuyến bay CORS, nhưng chúng tôi có thể sử dụng

{"id":1,"content":"Hello, User!"}

03 và chấp nhận một số JSON trong phần thân nếu chúng tôi muốn kích hoạt kiểm tra trước chuyến bay

{"id":1,"content":"Hello, User!"}

04 liên kết giá trị của tham số chuỗi truy vấn

{"id":1,"content":"Hello, User!"}

7 vào tham số

{"id":1,"content":"Hello, User!"}

7 của phương thức

{"id":1,"content":"Hello, World!"}

89. Tham số chuỗi truy vấn này không phải là

{"id":1,"content":"Hello, User!"}

08. Nếu nó không có trong yêu cầu, thì

{"id":1,"content":"Hello, User!"}

09 của

{"id":1,"content":"Hello, User!"}

9 được sử dụng

Việc triển khai phần thân phương thức tạo và trả về một đối tượng

{"id":1,"content":"Hello, World!"}

80 mới, với giá trị của thuộc tính

{"id":1,"content":"Hello, World!"}

65 dựa trên giá trị tiếp theo từ

{"id":1,"content":"Hello, User!"}

63 và giá trị của

{"id":1,"content":"Hello, World!"}

66 dựa trên tham số truy vấn hoặc giá trị mặc định. Nó cũng định dạng

{"id":1,"content":"Hello, User!"}

7 đã cho bằng cách sử dụng lời chào

{"id":1,"content":"Hello, User!"}

Một điểm khác biệt chính giữa bộ điều khiển MVC truyền thống và bộ điều khiển dịch vụ web RESTful được hiển thị trước đó là cách mà phần thân phản hồi HTTP được tạo. Thay vì dựa vào công nghệ chế độ xem để thực hiện hiển thị phía máy chủ của dữ liệu lời chào thành HTML, bộ điều khiển dịch vụ web RESTful này sẽ điền và trả về một đối tượng

{"id":1,"content":"Hello, World!"}

80. Dữ liệu đối tượng được ghi trực tiếp vào phản hồi HTTP dưới dạng JSON

Để thực hiện điều này, chú thích {RestController}[

{"id":1,"content":"Hello, User!"}

68] giả định rằng mọi phương thức đều kế thừa ngữ nghĩa của

{"id":1,"content":"Hello, User!"}

69 theo mặc định. Do đó, dữ liệu đối tượng trả về được chèn trực tiếp vào nội dung phản hồi

Nhờ hỗ trợ trình chuyển đổi thông báo HTTP của Spring, đối tượng

{"id":1,"content":"Hello, World!"}

80 được chuyển đổi thành JSON một cách tự nhiên. Bởi vì Jackson đang ở trên classpath, nên Spring's

//localhost:8080/greeting?name=User

21 sẽ tự động được chọn để chuyển đổi thể hiện

{"id":1,"content":"Hello, World!"}

80 thành JSON

Kích hoạt CORS

Bạn có thể kích hoạt tính năng chia sẻ tài nguyên trên nhiều nguồn gốc [CORS] từ trong các bộ điều khiển riêng lẻ hoặc trên toàn cầu. Các chủ đề sau đây mô tả cách thực hiện

Phương thức điều khiển Cấu hình CORS
Cấu hình CORS toàn cầu

Phương thức điều khiển Cấu hình CORS

Để dịch vụ web RESTful sẽ bao gồm các tiêu đề kiểm soát truy cập CORS trong phản hồi của nó, bạn phải thêm chú thích

//localhost:8080/greeting?name=User

23 vào phương thức xử lý, như danh sách sau [từ

{"id":1,"content":"Hello, World!"}

83] hiển thị

//localhost:8080/greeting?name=User

Chú thích

//localhost:8080/greeting?name=User

23 này chỉ cho phép chia sẻ tài nguyên trên nhiều nguồn gốc cho phương thức cụ thể này. Theo mặc định, nó cho phép tất cả các nguồn gốc, tất cả các tiêu đề và các phương thức HTTP được chỉ định trong chú thích

{"id":1,"content":"Hello, World!"}

87. Ngoài ra, một

//localhost:8080/greeting?name=User

27 trong 30 phút được sử dụng. Bạn có thể tùy chỉnh hành vi này bằng cách chỉ định giá trị của một trong các thuộc tính chú thích sau

```
//localhost:8080/greeting?name=User
```
28
```
//localhost:8080/greeting?name=User
```
29
```
{"id":1,"content":"Hello, User!"}
```
00
```
{"id":1,"content":"Hello, User!"}
```
01
```
{"id":1,"content":"Hello, User!"}
```
02
```
//localhost:8080/greeting?name=User
```
27

Trong ví dụ này, chúng tôi chỉ cho phép

{"id":1,"content":"Hello, User!"}

04 gửi yêu cầu nguồn gốc chéo

Bạn cũng có thể thêm chú thích

//localhost:8080/greeting?name=User

23 ở cấp lớp trình điều khiển để bật CORS trên tất cả các phương thức xử lý của lớp này

Cấu hình CORS toàn cầu

Ngoài [hoặc là một giải pháp thay thế] cho cấu hình dựa trên chú thích chi tiết, bạn cũng có thể xác định một số cấu hình CORS toàn cầu. Điều này tương tự như sử dụng một

{"id":1,"content":"Hello, User!"}

06 nhưng có thể được khai báo trong Spring MVC và kết hợp với cấu hình chi tiết của

//localhost:8080/greeting?name=User

23. Theo mặc định, tất cả các nguồn gốc và phương thức

{"id":1,"content":"Hello, World!"}

60,

{"id":1,"content":"Hello, User!"}

09 và

//localhost:8080/greeting?name=User

00 đều được phép

Danh sách sau [từ

{"id":1,"content":"Hello, World!"}

83] hiển thị phương thức

//localhost:8080/greeting?name=User

02 trong lớp

{"id":1,"content":"Hello, World!"}

//localhost:8080/greeting?name=User

Sự khác biệt giữa phương pháp

//localhost:8080/greeting?name=User

02 và phương pháp

//localhost:8080/greeting?name=User

05 [được sử dụng trong cấu hình CORS cấp bộ điều khiển] là tuyến đường [

//localhost:8080/greeting?name=User

06 chứ không phải

{"id":1,"content":"Hello, World!"}

61] và sự hiện diện của nguồn gốc

//localhost:8080/greeting?name=User

Danh sách sau [từ

//localhost:8080/greeting?name=User

09] cho biết cách thêm ánh xạ CORS vào lớp ứng dụng

//localhost:8080/greeting?name=User

Bạn có thể dễ dàng thay đổi bất kỳ thuộc tính nào [chẳng hạn như

//localhost:8080/greeting?name=User

10 trong ví dụ], cũng như áp dụng cấu hình CORS này cho một mẫu đường dẫn cụ thể

Bạn có thể kết hợp cấu hình CORS cấp toàn cầu và cấp bộ điều khiển

Tạo lớp ứng dụng

Spring Initializr tạo một lớp ứng dụng cơ bản cho bạn. Danh sách sau [từ

//localhost:8080/greeting?name=User

11] cho thấy lớp ban đầu

//localhost:8080/greeting?name=User

Bạn cần thêm một phương thức để định cấu hình cách xử lý chia sẻ tài nguyên trên nhiều nguồn gốc. Danh sách sau đây [từ

//localhost:8080/greeting?name=User

12] cho biết cách thực hiện

//localhost:8080/greeting?name=User

Danh sách sau đây cho thấy lớp ứng dụng đã hoàn thành

//localhost:8080/greeting?name=User

//localhost:8080/greeting?name=User

13 là một chú thích tiện lợi có thêm tất cả những điều sau đây

```
//localhost:8080/greeting?name=User
```
14. Gắn thẻ lớp làm nguồn định nghĩa bean cho ngữ cảnh ứng dụng
```
//localhost:8080/greeting?name=User
```
15. Yêu cầu Spring Boot bắt đầu thêm các bean dựa trên cài đặt đường dẫn lớp, các bean khác và các cài đặt thuộc tính khác nhau. Ví dụ: nếu
```
//localhost:8080/greeting?name=User
```
16 nằm trên đường dẫn lớp, thì chú thích này sẽ đánh dấu ứng dụng là ứng dụng web và kích hoạt các hành vi chính, chẳng hạn như thiết lập một
```
//localhost:8080/greeting?name=User
```
17
```
//localhost:8080/greeting?name=User
```
18. Yêu cầu Spring tìm kiếm các thành phần, cấu hình và dịch vụ khác trong gói
```
//localhost:8080/greeting?name=User
```
19, cho phép nó tìm bộ điều khiển

Phương thức

//localhost:8080/greeting?name=User

20 sử dụng phương thức

//localhost:8080/greeting?name=User

21 của Spring Boot để khởi chạy một ứng dụng. Bạn có nhận thấy rằng không có một dòng XML nào không? . Ứng dụng web này là Java thuần 100% và bạn không phải đối phó với việc định cấu hình bất kỳ hệ thống ống nước hoặc cơ sở hạ tầng nào

Xây dựng một JAR thực thi

Bạn có thể chạy ứng dụng từ dòng lệnh với Gradle hoặc Maven. Bạn cũng có thể tạo một tệp JAR có thể thực thi duy nhất chứa tất cả các phụ thuộc, lớp và tài nguyên cần thiết rồi chạy tệp đó. Xây dựng một jar thực thi giúp dễ dàng vận chuyển, tạo phiên bản và triển khai dịch vụ dưới dạng một ứng dụng trong suốt vòng đời phát triển, trên các môi trường khác nhau, v.v.

Nếu bạn sử dụng Gradle, bạn có thể chạy ứng dụng bằng cách sử dụng

//localhost:8080/greeting?name=User

23. Ngoài ra, bạn có thể tạo tệp JAR bằng cách sử dụng

//localhost:8080/greeting?name=User

24 rồi chạy tệp JAR, như sau

//localhost:8080/greeting?name=User

Nếu bạn sử dụng Maven, bạn có thể chạy ứng dụng bằng cách sử dụng

//localhost:8080/greeting?name=User

25. Ngoài ra, bạn có thể xây dựng tệp JAR bằng

//localhost:8080/greeting?name=User

26 rồi chạy tệp JAR như sau

//localhost:8080/greeting?name=User

Các bước được mô tả ở đây tạo một JAR có thể chạy được. Bạn cũng có thể tạo tệp WAR cổ điển

Đầu ra ghi nhật ký được hiển thị. Dịch vụ sẽ được thiết lập và chạy trong vòng vài giây

Kiểm tra dịch vụ

Bây giờ dịch vụ đã hoạt động, hãy truy cập

{"id":1,"content":"Hello, User!"}

6 trong trình duyệt của bạn, nơi bạn sẽ thấy

{"id":1,"content":"Hello, World!"}

Cung cấp tham số chuỗi truy vấn

{"id":1,"content":"Hello, User!"}

7 bằng cách truy cập

//localhost:8080/greeting?name=User

29. Giá trị của thuộc tính

{"id":1,"content":"Hello, World!"}

66 thay đổi từ

//localhost:8080/greeting?name=User

31 thành

//localhost:8080/greeting?name=User

32, như danh sách sau đây cho thấy

//localhost:8080/greeting?name=User

Thay đổi này chứng tỏ rằng sắp xếp

{"id":1,"content":"Hello, User!"}

04 trong

{"id":1,"content":"Hello, World!"}

82 hoạt động như mong đợi. Tham số

{"id":1,"content":"Hello, User!"}

7 đã được cung cấp giá trị mặc định là

{"id":1,"content":"Hello, User!"}

9 nhưng luôn có thể được ghi đè rõ ràng thông qua chuỗi truy vấn

Ngoài ra, thuộc tính

{"id":1,"content":"Hello, World!"}

65 đã thay đổi từ

//localhost:8080/greeting?name=User

38 thành

//localhost:8080/greeting?name=User

39. Điều này chứng tỏ rằng bạn đang làm việc với cùng một phiên bản

{"id":1,"content":"Hello, World!"}

82 qua nhiều yêu cầu và trường

{"id":1,"content":"Hello, User!"}

63 của nó đang được tăng dần trên mỗi lệnh gọi, như dự kiến

Giờ đây, bạn có thể kiểm tra xem các tiêu đề CORS đã ở đúng vị trí chưa và cho phép ứng dụng khách Javascript từ nguồn gốc khác truy cập dịch vụ. Để làm như vậy, bạn cần tạo một ứng dụng khách Javascript để sử dụng dịch vụ. Danh sách sau đây cho thấy một khách hàng như vậy

Đầu tiên, tạo một tệp Javascript đơn giản có tên là

//localhost:8080/greeting?name=User

42 [từ

//localhost:8080/greeting?name=User

43] với nội dung sau

{"id":1,"content":"Hello, User!"}

Tập lệnh này sử dụng jQuery để sử dụng dịch vụ REST tại

{"id":1,"content":"Hello, User!"}

6. Nó được tải bởi

//localhost:8080/greeting?name=User

45, như danh sách sau [từ

//localhost:8080/greeting?name=User

46] cho thấy

{"id":1,"content":"Hello, User!"}

Đây thực chất là ứng dụng khách REST được tạo trong Sử dụng dịch vụ web RESTful với jQuery, được sửa đổi một chút để sử dụng dịch vụ khi nó chạy trên máy chủ cục bộ tại cổng 8080. Xem hướng dẫn đó để biết thêm chi tiết về cách khách hàng này được phát triển

Để khởi động client chạy trên localhost tại cổng 8080, hãy chạy lệnh Maven sau

{"id":1,"content":"Hello, User!"}

Nếu bạn sử dụng Gradle, bạn có thể sử dụng lệnh này

{"id":1,"content":"Hello, User!"}

Khi ứng dụng bắt đầu, hãy mở http. //máy chủ cục bộ. 8080 trong trình duyệt của bạn, nơi bạn sẽ thấy như sau

Để kiểm tra hoạt động của CORS, bạn cần khởi động ứng dụng khách từ một máy chủ hoặc cổng khác. Làm như vậy không chỉ tránh xung đột giữa hai ứng dụng mà còn đảm bảo rằng mã máy khách được phục vụ từ nguồn gốc khác với dịch vụ. Để khởi động ứng dụng chạy trên localhost tại cổng 9000 [cũng như ứng dụng đang chạy trên cổng 8080], hãy chạy lệnh Maven sau

{"id":1,"content":"Hello, User!"}

Nếu bạn sử dụng Gradle, bạn có thể sử dụng lệnh này

{"id":1,"content":"Hello, User!"}

Khi ứng dụng bắt đầu, hãy mở http. //máy chủ cục bộ. 9000 trong trình duyệt của bạn, nơi bạn sẽ thấy như sau

Nếu phản hồi của dịch vụ bao gồm các tiêu đề CORS thì ID và nội dung sẽ được hiển thị trên trang. Nhưng nếu các tiêu đề CORS bị thiếu [hoặc không đủ cho máy khách], trình duyệt sẽ không thực hiện được yêu cầu và các giá trị không được hiển thị trong DOM

Bản tóm tắt

Xin chúc mừng. Bạn vừa phát triển một dịch vụ web RESTful bao gồm Chia sẻ tài nguyên nguồn gốc chéo với Spring

Xem thêm

Các hướng dẫn sau đây cũng có thể hữu ích

Xây dựng một dịch vụ web RESTful
Xây dựng Dịch vụ web RESTful dựa trên Hypermedia
Tạo tài liệu API với Restdocs
Truy cập dữ liệu GemFire bằng REST
Truy cập dữ liệu MongoDB bằng REST
Truy cập dữ liệu với MySQL
Truy cập dữ liệu JPA bằng REST
Truy cập dữ liệu Neo4j bằng REST
Sử dụng một dịch vụ web RESTful
Sử dụng Dịch vụ web RESTful với AngularJS
Sử dụng Dịch vụ web RESTful với jQuery
Sử dụng Dịch vụ web RESTful với phần còn lại. js
Bảo mật ứng dụng web
Xây dựng các dịch vụ REST với Spring
Phản ứng. js và dữ liệu mùa xuân REST
Xây dựng một ứng dụng với Spring Boot

Bạn muốn viết một hướng dẫn mới hoặc đóng góp cho một hướng dẫn hiện có?

Tất cả các hướng dẫn được phát hành với giấy phép ASLv2 cho mã và giấy phép Commons sáng tạo Attribution, NoDerivatives cho văn bản

Truy cập như thế nào

Kiểm soát truy cập-Cho phép-Xuất xứ là tiêu đề CORS [chia sẻ tài nguyên gốc chéo]. Khi Trang web A cố gắng tìm nạp nội dung từ Trang web B, Trang web B có thể gửi tiêu đề phản hồi Kiểm soát truy cập-Cho phép-Xuất xứ để thông báo cho trình duyệt rằng nội dung của trang này có thể truy cập được từ một số nguồn nhất định

* trong Access là gì

Kiểm soát truy cập-Cho phép-Xuất xứ chỉ định một nguồn gốc duy nhất thông báo cho các trình duyệt cho phép nguồn gốc đó truy cập tài nguyên; . tells browsers to allow any origin to access the resource.

Sử dụng Access có an toàn không

Kiểm soát truy cập-Cho phép-Xuất xứ. * là hoàn toàn an toàn để thêm vào bất kỳ tài nguyên nào, trừ khi tài nguyên đó chứa dữ liệu riêng tư được bảo vệ bởi thứ gì đó không phải là thông tin xác thực tiêu chuẩn . Thông tin xác thực tiêu chuẩn là cookie, xác thực cơ bản HTTP và chứng chỉ ứng dụng khách TLS.

Truy cập là gì

Lỗi này xảy ra khi một tập lệnh trên trang web/ứng dụng web của bạn cố gắng đưa ra yêu cầu đối với tài nguyên không được định cấu hình để chấp nhận các yêu cầu đến từ mã không đến từ cùng một miền [phụ], do đó vi phạm Same-Origin