當前位置：首頁 > 编程语言 > java >内容正文

java

oidc_使用Java EE和OIDC构建Java REST API

發布時間：2023/12/3 java 29 豆豆

生活随笔收集整理的這篇文章主要介紹了 oidc_使用Java EE和OIDC构建Java REST API 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

oidc

“我喜歡編寫身份驗證和授權代碼。” ?從來沒有Java開發人員。厭倦了一次又一次地建立相同的登錄屏幕？嘗試使用Okta API進行托管身份驗證，授權和多因素身份驗證。

Java EE允許您使用JAX-RS和JPA快速輕松地構建Java REST API。 Java EE是保護傘標準規范，它描述了許多Java技術，包括EJB，JPA，JAX-RS和許多其他技術。它最初旨在允許Java應用程序服務器之間的可移植性，并在2000年代初期蓬勃發展。那時，應用程序服務器風行一時，并由許多知名公司（例如IBM，BEA和Sun）提供。 JBoss是一家新興公司，它破壞了現狀，并表明有可能將Java EE應用服務器開發為一個開源項目，并免費提供它。 JBoss在2006年被RedHat收購。

在2000年代初期，Java開發人員使用servlet和EJB來開發其服務器應用程序。 Hibernate和Spring分別于2002年和2004年問世。兩種技術都對各地的Java開發人員產生了巨大的影響，表明他們可以編寫沒有EJB的分布式，健壯的應用程序。 Hibernate的POJO模型最終被用作JPA標準，并且對EJB的影響也很大。

快進到2018年，Java EE肯定不像以前那樣！現在，它主要是POJO和注釋，并且使用起來更簡單。

為什么要使用Java EE而不是Spring Boot構建Java REST API？

Spring Boot是Java生態系統中我最喜歡的技術之一。它極大地減少了Spring應用程序中必需的配置，并使得僅用幾行代碼即可生成REST API。但是，最近有一些不使用Spring Boot的開發人員提出了許多API安全性問題。其中一些甚至沒有使用Spring！

出于這個原因，我認為構建一個Java REST API（使用Java EE）很有趣，該API與我過去開發的Spring Boot REST API相同。即，我的Bootiful Angular和Bootiful React帖子中的“啤酒” API。

使用Java EE構建Java REST API

首先，我在Twitter上詢問了我的網絡，是否存在諸如start.spring.io之類的Java EE快速入門。我收到了一些建議，并開始進行一些研究。 David Blevins建議我看一下tomee-jaxrs-starter-project ，所以我從那里開始。我還研究了Roberto Cortez推薦的TomEE Maven原型。

我喜歡jaxrs-starter項目，因為它展示了如何使用JAX-RS創建REST API。 TomEE Maven原型也很有用，特別是因為它展示了如何使用JPA，H2和JSF。我將兩者結合在一起，創建了自己的最小啟動器，可用于在TomEE上實現安全的Java EE API。您不必在這些示例中使用TomEE，但是我尚未在其他實現上對其進行測試。

如果您在其他應用服務器上使用了這些示例，請告訴我，我將更新此博客文章。

在這些示例中，我將使用Java 8和Java EE 7.0以及TomEE 7.1.0。 TomEE 7.x是EE 7兼容版本；有一個TomEE 8.x分支用于EE8兼容性工作，但尚無發行版本。我希望您也安裝了Apache Maven 。

首先，將我們的Java EE REST API存儲庫克隆到您的硬盤驅動器，然后運行它：

git clone https://github.com/oktadeveloper/okta-java-ee-rest-api-example.git javaee-rest-api cd javaee-rest-api mvn package tomee:run

導航到http：// localhost：8080并添加新啤酒。

單擊添加，您應該看到成功消息。

單擊查看存在的啤酒以查看啤酒的完整列表。

您還可以在http://localhost:8080/good-beers查看系統中的優質啤酒列表。以下是使用HTTPie時的輸出。

$ http :8080/good-beers HTTP/1.1 200 Content-Type: application/json Date: Wed, 29 Aug 2018 21:58:23 GMT Server: Apache TomEE Transfer-Encoding: chunked[{"id": 101,"name": "Kentucky Brunch Brand Stout"},{"id": 102,"name": "Marshmallow Handjee"},{"id": 103,"name": "Barrel-Aged Abraxas"},{"id": 104,"name": "Heady Topper"},{"id": 108,"name": "White Rascal"} ]

使用Java EE構建REST API

我向您展示了該應用程序可以做什么，但是我還沒有談論它是如何構建的。它有一些XML配置文件，但是我將跳過其中的大多數。目錄結構如下所示：

$ tree . . ├── LICENSE ├── README.md ├── pom.xml └── src├── main│ ├── java│ │ └── com│ │ └── okta│ │ └── developer│ │ ├── Beer.java│ │ ├── BeerBean.java│ │ ├── BeerResource.java│ │ ├── BeerService.java│ │ └── StartupBean.java│ ├── resources│ │ └── META-INF│ │ └── persistence.xml│ └── webapp│ ├── WEB-INF│ │ ├── beans.xml│ │ └── faces-config.xml│ ├── beer.xhtml│ ├── index.jsp│ └── result.xhtml└── test└── resources└── arquillian.xml12 directories, 16 files

最重要的XML文件是pom.xml ，它定義了依賴關系，并允許您運行TomEE Maven插件。它很短很甜，只有一個依賴項和一個插件。

<?xml version="1.0" encoding="UTF-8"?> <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.okta.developer</groupId><artifactId>java-ee-rest-api</artifactId><version>1.0-SNAPSHOT</version><packaging>war</packaging><name>Java EE Webapp with JAX-RS API</name><url>http://developer.okta.com</url><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><maven.compiler.target>1.8</maven.compiler.target><maven.compiler.source>1.8</maven.compiler.source><failOnMissingWebXml>false</failOnMissingWebXml><javaee-api.version>7.0</javaee-api.version><tomee.version>7.1.0</tomee.version></properties><dependencies><dependency><groupId>javax</groupId><artifactId>javaee-api</artifactId><version>${javaee-api.version}</version><scope>provided</scope></dependency></dependencies><build><plugins><plugin><groupId>org.apache.tomee.maven</groupId><artifactId>tomee-maven-plugin</artifactId><version>${tomee.version}</version><configuration><context>ROOT</context></configuration></plugin></plugins></build> </project>

主要實體是Beer.java 。

package com.okta.developer;import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;@Entity public class Beer {@Id@GeneratedValue(strategy = GenerationType.AUTO)private int id;private String name;public Beer() {}public Beer(String name) {this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String beerName) {this.name = beerName;}@Overridepublic String toString() {return "Beer{" +"id=" + id +", name='" + name + '\'' +'}';} }

數據庫（又名數據源）在src/main/resources/META-INF/persistence.xml 。

<?xml version="1.0" encoding="UTF-8"?> <persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"><persistence-unit name="beer-pu" transaction-type="JTA"><jta-data-source>beerDatabase</jta-data-source><class>com.okta.developer.Beer</class><properties><property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/></properties></persistence-unit> </persistence>

BeerService.java類使用JPA的EntityManager處理該實體的讀取并將其保存到數據庫。

package com.okta.developer;import javax.ejb.Stateless; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import javax.persistence.Query; import javax.persistence.criteria.CriteriaQuery; import java.util.List;@Stateless public class BeerService {@PersistenceContext(unitName = "beer-pu")private EntityManager entityManager;public void addBeer(Beer beer) {entityManager.persist(beer);}public List<Beer> getAllBeers() {CriteriaQuery<Beer> cq = entityManager.getCriteriaBuilder().createQuery(Beer.class);cq.select(cq.from(Beer.class));return entityManager.createQuery(cq).getResultList();}public void clear() {Query removeAll = entityManager.createQuery("delete from Beer");removeAll.executeUpdate();} }

有一個StartupBean.java ，用于在啟動時填充數據庫，并在關閉時清除數據庫。

package com.okta.developer;import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import javax.ejb.Singleton; import javax.ejb.Startup; import javax.inject.Inject; import java.util.stream.Stream;@Singleton @Startup public class StartupBean {private final BeerService beerService;@Injectpublic StartupBean(BeerService beerService) {this.beerService = beerService;}@PostConstructprivate void startup() {// Top beers from https://www.beeradvocate.com/lists/top/Stream.of("Kentucky Brunch Brand Stout", "Marshmallow Handjee", "Barrel-Aged Abraxas", "Heady Topper","Budweiser", "Coors Light", "PBR").forEach(name ->beerService.addBeer(new Beer(name)));beerService.getAllBeers().forEach(System.out::println);}@PreDestroyprivate void shutdown() {beerService.clear();} }

這三個類構成了應用程序的基礎，還有一個BeerResource.java類，它使用JAX-RS公開/good-beers端點。

package com.okta.developer;import javax.ejb.Lock; import javax.ejb.Singleton; import javax.inject.Inject; import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; import java.util.List; import java.util.stream.Collectors;import static javax.ejb.LockType.READ; import static javax.ws.rs.core.MediaType.APPLICATION_JSON;@Lock(READ) @Singleton @Path("/good-beers") public class BeerResource {private final BeerService beerService;@Injectpublic BeerResource(BeerService beerService) {this.beerService = beerService;}@GET@Produces({APPLICATION_JSON})public List<Beer> getGoodBeers() {return beerService.getAllBeers().stream().filter(this::isGreat).collect(Collectors.toList());}private boolean isGreat(Beer beer) {return !beer.getName().equals("Budweiser") &&!beer.getName().equals("Coors Light") &&!beer.getName().equals("PBR");} }

最后，有一個BeerBean.java類用作JSF的托管bean。

package com.okta.developer;import javax.enterprise.context.RequestScoped; import javax.inject.Inject; import javax.inject.Named; import java.util.List;@Named @RequestScoped public class BeerBean {@Injectprivate BeerService beerService;private List<Beer> beersAvailable;private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public List<Beer> getBeersAvailable() {return beersAvailable;}public void setBeersAvailable(List<Beer> beersAvailable) {this.beersAvailable = beersAvailable;}public String fetchBeers() {beersAvailable = beerService.getAllBeers();return "success";}public String add() {Beer beer = new Beer();beer.setName(name);beerService.addBeer(beer);return "success";} }

您現在擁有了使用Java EE構建的REST API！但是，這并不安全。在以下各節中，我將向您展示如何使用Okta的Java JWT驗證程序，Spring Security和Pac4j保護它。

使用Okta將OIDC安全性添加到Java REST API

您將需要在Okta中創建OIDC應用程序，以驗證將要實施的安全配置。要使此操作毫不費力，可以使用Okta的OIDC API。在Okta，我們的目標是使身份管理比您以往更加輕松，安全和可擴展。 Okta是一項云服務，允許開發人員創建，編輯和安全地存儲用戶帳戶和用戶帳戶數據，并將它們與一個或多個應用程序連接。我們的API使您能夠：

驗證和授權您的用戶
存儲有關您的用戶的數據
執行基于密碼的社交登錄
通過多因素身份驗證保護您的應用程序
以及更多！查看我們的產品文檔

你賣了嗎立即注冊一個永久免費的開發者帳戶！完成后，請完成以下步驟以創建OIDC應用程序。

登錄到您在developer.okta.com上的開發者帳戶。

導航至應用程序 ，然后單擊添加應用程序 。

選擇Web ，然后單擊Next 。

為應用程序命名（例如Java EE Secure API ），然后添加以下內容作為登錄重定向URI：

http://localhost:3000/implicit/callback
http://localhost:8080/login/oauth2/code/okta
http://localhost:8080/callback?client_name=OidcClient

單擊完成，然后編輯項目并啟用“隱式（混合）”作為授予類型（允許ID和訪問令牌），然后單擊保存。

使用JWT Verifier保護Java REST API

要從Okta驗證JWT，您需要將Okta Java JWT Verifier添加到pom.xml 。

<properties>...<okta-jwt.version>0.3.0</okta-jwt.version> </properties><dependencies>...<dependency><groupId>com.okta.jwt</groupId><artifactId>okta-jwt-verifier</artifactId><version>${okta-jwt.version}</version></dependency> </dependencies>

然后創建一個JwtFilter.java （在src/main/java/com/okta/developer目錄中）。此過濾器查找其中包含訪問令牌的authorization標頭。如果存在，它將對其進行驗證并打印出用戶的sub ，也就是他們的電子郵件地址。如果不存在或無效，則返回拒絕訪問狀態。

確保使用您創建的應用中的設置替換{yourOktaDomain}和{clientId} 。

package com.okta.developer;import com.nimbusds.oauth2.sdk.ParseException; import com.okta.jwt.JoseException; import com.okta.jwt.Jwt; import com.okta.jwt.JwtHelper; import com.okta.jwt.JwtVerifier;import javax.servlet.*; import javax.servlet.annotation.WebFilter; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException;@WebFilter(filterName = "jwtFilter", urlPatterns = "/*") public class JwtFilter implements Filter {private JwtVerifier jwtVerifier;@Overridepublic void init(FilterConfig filterConfig) {try {jwtVerifier = new JwtHelper().setIssuerUrl("https://{yourOktaDomain}/oauth2/default").setClientId("{yourClientId}").build();} catch (IOException | ParseException e) {System.err.print("Configuring JWT Verifier failed!");e.printStackTrace();}}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,FilterChain chain) throws IOException, ServletException {HttpServletRequest request = (HttpServletRequest) servletRequest;HttpServletResponse response = (HttpServletResponse) servletResponse;System.out.println("In JwtFilter, path: " + request.getRequestURI());// Get access token from authorization headerString authHeader = request.getHeader("authorization");if (authHeader == null) {response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Access denied.");return;} else {String accessToken = authHeader.substring(authHeader.indexOf("Bearer ") + 7);try {Jwt jwt = jwtVerifier.decodeAccessToken(accessToken);System.out.println("Hello, " + jwt.getClaims().get("sub"));} catch (JoseException e) {e.printStackTrace();response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Access denied.");return;}}chain.doFilter(request, response);}@Overridepublic void destroy() {} }

為確保此過濾器正常工作，請重新啟動您的應用并運行：

mvn package tomee:run

如果在瀏覽器中導航到http://localhost:8080/good-beers ，則會看到拒絕訪問錯誤。

為了證明它可以與有效的JWT一起使用，您可以克隆我的Bootiful React項目，并運行其UI：

git clone -b okta https://github.com/oktadeveloper/spring-boot-react-example.git bootiful-react cd bootiful-react/client npm install

編輯此項目的client/src/App.tsx文件，并更改issuer和clientId以匹配您的應用程序。

const config = {issuer: 'https://{yourOktaDomain}/oauth2/default',redirectUri: window.location.origin + '/implicit/callback',clientId: '{yourClientId}' };

然后啟動它：

npm start

然后，您應該能夠使用創建帳戶所用的憑據登錄http://localhost:3000 。但是，由于CORS錯誤（在瀏覽器的開發人員控制臺中），您將無法從API加載任何啤酒。

Failed to load http://localhost:8080/good-beers: Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:3000' is therefore not allowed access.

提示：如果看到401并且沒有CORS錯誤，則可能意味著您的客戶ID不匹配。

要解決此CORS錯誤，請在JwtFilter.java類旁邊添加一個CorsFilter.java 。下面的過濾器將允許OPTIONS請求，并向后發送訪問控制標頭，該標頭允許任何原始，GET方法和任何標頭。我建議您在生產中使這些設置更加具體。

package com.okta.developer;import javax.servlet.*; import javax.servlet.annotation.WebFilter; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException;@WebFilter(filterName = "corsFilter") public class CorsFilter implements Filter {@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain)throws IOException, ServletException {HttpServletRequest request = (HttpServletRequest) servletRequest;HttpServletResponse response = (HttpServletResponse) servletResponse;System.out.println("In CorsFilter, method: " + request.getMethod());// Authorize (allow) all domains to consume the contentresponse.addHeader("Access-Control-Allow-Origin", "http://localhost:3000");response.addHeader("Access-Control-Allow-Methods", "GET");response.addHeader("Access-Control-Allow-Headers", "*");// For HTTP OPTIONS verb/method reply with ACCEPTED status code -- per CORS handshakeif (request.getMethod().equals("OPTIONS")) {response.setStatus(HttpServletResponse.SC_ACCEPTED);return;}// pass the request along the filter chainchain.doFilter(request, response);}@Overridepublic void init(FilterConfig config) {}@Overridepublic void destroy() {} }

您添加的兩個過濾器都使用@WebFilter進行注冊。這是一個方便的注釋，但不提供任何過濾器排序功能。要解決此缺失的功能，請修改JwtFilter ，使其在@WebFilter中沒有urlPattern 。

@WebFilter(filterName = "jwtFilter")

然后創建一個src/main/webapp/WEB-INF/web.xml文件，并使用以下XML進行填充。這些過濾器映射可確保CorsFilter處理CorsFilter 。

<?xml version="1.0" encoding="UTF-8"?> <web-app version="3.1"xmlns="http://xmlns.jcp.org/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"><filter-mapping><filter-name>corsFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><filter-mapping><filter-name>jwtFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping> </web-app>

重新啟動Java API，現在一切正常！

在控制臺中，您應該看到類似于我的消息：

In CorsFilter, method: OPTIONS In CorsFilter, method: GET In JwtFilter, path: /good-beers Hello, demo@okta.com

使用Okta的JWT驗證程序過濾器是實現資源服務器的一種簡單方法（采用OAuth 2.0命名法）。但是，它不向您提供有關該用戶的任何信息。 JwtVerifier接口的確有一個decodeIdToken(String idToken, String nonce)方法，但是您必須從客戶端傳遞ID令牌才能使用它。

在接下來的兩節中，我將向您展示如何使用Spring Security和Pac4j來實現類似的安全性。另外，我將向您展示如何提示用戶登錄（當他們嘗試直接訪問API時）并獲取用戶的信息。

通過Spring Security保護Java REST API

Spring Security是我在Javaland中最喜歡的框架之一。在顯示如何使用Spring Security時，此博客上的大多數示例都使用Spring Boot。我將使用最新版本– 5.1.0.RC2 –因此本教程將保持最新狀態。

還原更改以添加JWT Verifier，或直接刪除web.xml繼續。

修改您的pom.xml使其具有Spring Security所需的依賴關系。您還需要添加Spring的快照存儲庫以獲得候選版本。

<properties>...<spring-security.version>5.1.0.RC2</spring-security.version><spring.version>5.1.0.RC3</spring.version><jackson.version>2.9.6</jackson.version> </properties><dependencyManagement><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-framework-bom</artifactId><version>${spring.version}</version><scope>import</scope><type>pom</type></dependency><dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-bom</artifactId><version>${spring-security.version}</version><scope>import</scope><type>pom</type></dependency></dependencies> </dependencyManagement><dependencies>...<dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId></dependency><dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-web</artifactId></dependency><dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-config</artifactId></dependency><dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-oauth2-client</artifactId></dependency><dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-oauth2-resource-server</artifactId></dependency><dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-oauth2-jose</artifactId></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-core</artifactId><version>${jackson.version}</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>${jackson.version}</version></dependency> </dependencies><pluginRepositories><pluginRepository><id>spring-snapshots</id><name>Spring Snapshots</name><url>https://repo.spring.io/libs-snapshot</url><snapshots><enabled>true</enabled></snapshots></pluginRepository> </pluginRepositories> <repositories><repository><id>spring-snapshots</id><name>Spring Snapshot</name><url>https://repo.spring.io/libs-snapshot</url></repository> </repositories>

在src/main/java/com/okta/developer創建一個SecurityWebApplicationInitializer.java類：

package com.okta.developer;import org.springframework.security.web.context.*;public class SecurityWebApplicationInitializerextends AbstractSecurityWebApplicationInitializer {public SecurityWebApplicationInitializer() {super(SecurityConfiguration.class);} }

在同一目錄中創建一個SecurityConfiguration.java類。此類使用Spring Security 5的oauth2Login()并向Spring Security注冊您的Okta應用程序。

package com.okta.developer;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.PropertySource; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.config.http.SessionCreationPolicy; import org.springframework.security.oauth2.client.InMemoryOAuth2AuthorizedClientService; import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService; import org.springframework.security.oauth2.client.registration.ClientRegistration; import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository; import org.springframework.security.oauth2.client.registration.ClientRegistrations; import org.springframework.security.oauth2.client.registration.InMemoryClientRegistrationRepository; import org.springframework.security.web.csrf.CookieCsrfTokenRepository;@Configuration @EnableWebSecurity @PropertySource("classpath:application.properties") public class SecurityConfiguration extends WebSecurityConfigurerAdapter {private final String clientSecret;private final String clientId;private final String issuerUri;@Autowiredpublic SecurityConfiguration(@Value("${okta.issuer-uri}") String issuerUri,@Value("${okta.client-id}") String clientId,@Value("${okta.client-secret}") String clientSecret) {this.issuerUri = issuerUri;this.clientId = clientId;this.clientSecret = clientSecret;}@Overrideprotected void configure(HttpSecurity http) throws Exception {http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.ALWAYS).and().csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()).and().authorizeRequests().anyRequest().authenticated().and().oauth2Login();}@Beanpublic OAuth2AuthorizedClientService authorizedClientService() {return new InMemoryOAuth2AuthorizedClientService(clientRegistrationRepository());}@Beanpublic ClientRegistrationRepository clientRegistrationRepository() {List<ClientRegistration> registrations = clients.stream().map(this::getRegistration).filter(Objects::nonNull).collect(Collectors.toList());return new InMemoryClientRegistrationRepository(registrations);}@Beanpublic ClientRegistrationRepository clientRegistrationRepository() {ClientRegistration okta = getRegistration();return new InMemoryClientRegistrationRepository(okta);}ClientRegistrations.fromOidcIssuerLocation(Objects.requireNonNull(issuerUri)).registrationId("okta").clientId(clientId).clientSecret(clientSecret).build(); }

創建src/main/resources/application.properties并用Okta OIDC應用設置進行填充。

okta.client-id={clientId} okta.client-secret={clientSecret} okta.issuer-uri=https://{yourOktaDomain}/oauth2/default

感謝Baeldung提供有關Spring Security 5 OAuth的出色文檔。

因為啟用了CSRF，所以必須在任何<h:form>標記內添加以下隱藏字段以保護CSRF。我將以下內容添加到src/main/webapp/beer.xhtml和result.xhtml 。

重新啟動您的API（ mvn clean package tomee:run ）并導航到http://localhost:8080/good-beers 。您應該重定向到Okta進行登錄。

輸入有效的憑證，您應該在瀏覽器中看到JSON。 JSON Viewer Chrome插件提供了美觀的JSON。

要求用戶登錄以查看您的API數據很方便，但是最好將其作為React UI示例的資源服務器。 OAuth 2.0資源服務器支持是Spring Security 5.1.0 RC1中的新增功能，因此我將向您展示如何使用它。

用以下代碼替換SecurityConfiguration.java的configure()方法，該代碼啟用CORS并設置資源服務器。

@Override protected void configure(HttpSecurity http) throws Exception {http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.ALWAYS).and().csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()).and().cors().and().authorizeRequests().anyRequest().authenticated().and().oauth2Login().and().oauth2ResourceServer().jwt(); }@Bean JwtDecoder jwtDecoder() {return JwtDecoders.fromOidcIssuerLocation(this.issuerUri); }@Bean CorsConfigurationSource corsConfigurationSource() {CorsConfiguration configuration = new CorsConfiguration();configuration.setAllowCredentials(true);configuration.setAllowedOrigins(Collections.singletonList("http://localhost:3000"));configuration.setAllowedMethods(Collections.singletonList("GET"));configuration.setAllowedHeaders(Collections.singletonList("*"));UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();source.registerCorsConfiguration("/**", configuration);return source; }

進行這些更改后，重新啟動您的API并確認您的React UI可以與之對話。很漂亮吧？

Spring Security的用戶信息

Spring Security與Servlet API集成在一起，因此您可以使用以下方法來獲取當前用戶的信息。

HttpServletRequest.getRemoteUser()
HttpServletRequest.getUserPrincipal()

擁有Principal ，您可以獲取有關用戶的詳細信息，包括其角色（又名，權限）。

OAuth2Authentication authentication = (OAuth2Authentication) principal; Map<String, Object> user = (Map<String, Object>) authentication.getUserAuthentication().getDetails();

請參閱Spring Security的Servlet API集成文檔以獲取更多信息。

使用Pac4j鎖定Java REST API

我想向您展示的確保Java REST API安全的最后一種技術是使用Pac4j，特別是j2e-pac4j 。

恢復您的更改以添加Spring Security。

git reset --hard HEAD

編輯pom.xml以添加完成本節所需的Pac4j庫。

<properties>...<pac4j-j2e.version>4.0.0</pac4j-j2e.version><pac4j.version>3.0.0</pac4j.version> </properties><dependencies>...<dependency><groupId>org.pac4j</groupId><artifactId>j2e-pac4j</artifactId><version>${pac4j-j2e.version}</version></dependency><dependency><groupId>org.pac4j</groupId><artifactId>pac4j-oidc</artifactId><version>${pac4j.version}</version></dependency><dependency><groupId>org.pac4j</groupId><artifactId>pac4j-http</artifactId><version>${pac4j.version}</version></dependency><dependency><groupId>org.pac4j</groupId><artifactId>pac4j-jwt</artifactId><version>${pac4j.version}</version></dependency> </dependencies>

就像創建JWT Verifier一樣，創建一個src/main/java/com/okta/developer/CorsFilter.java 。

在同一程序包中創建一個SecurityConfigFactory.java 。將客戶端ID，密鑰和域占位符替換為與OIDC應用程序匹配的占位符。

package com.okta.developer;import com.fasterxml.jackson.databind.ObjectMapper; import org.pac4j.core.client.Clients; import org.pac4j.core.client.direct.AnonymousClient; import org.pac4j.core.config.Config; import org.pac4j.core.config.ConfigFactory; import org.pac4j.core.credentials.TokenCredentials; import org.pac4j.core.profile.CommonProfile; import org.pac4j.http.client.direct.HeaderClient; import org.pac4j.jwt.config.signature.RSASignatureConfiguration; import org.pac4j.jwt.credentials.authenticator.JwtAuthenticator; import org.pac4j.jwt.util.JWKHelper; import org.pac4j.oidc.client.OidcClient; import org.pac4j.oidc.config.OidcConfiguration; import org.pac4j.oidc.profile.OidcProfile;import java.io.IOException; import java.net.URL; import java.security.KeyPair; import java.util.ArrayList; import java.util.List; import java.util.Map;public class SecurityConfigFactory implements ConfigFactory {private final JwtAuthenticator jwtAuthenticator = new JwtAuthenticator();private final ObjectMapper mapper = new ObjectMapper();@Overridepublic Config build(final Object... parameters) {System.out.print("Building Security configuration...\n");final OidcConfiguration oidcConfiguration = new OidcConfiguration();oidcConfiguration.setClientId("{yourClientId}");oidcConfiguration.setSecret("{yourClientSecret}");oidcConfiguration.setDiscoveryURI("https://{yourOktaDomain}/oauth2/default/.well-known/openid-configuration");oidcConfiguration.setUseNonce(true);final OidcClient<OidcProfile, OidcConfiguration> oidcClient = new OidcClient<>(oidcConfiguration);oidcClient.setAuthorizationGenerator((ctx, profile) -> {profile.addRole("ROLE_USER");return profile;});HeaderClient headerClient = new HeaderClient("Authorization", "Bearer ", (credentials, ctx) -> {String token = ((TokenCredentials) credentials).getToken();if (token != null) {try {// Get JWKURL keysUrl = new URL("https://{yourOktaDomain}/oauth2/default/v1/keys");Map map = mapper.readValue(keysUrl, Map.class);List keys = (ArrayList) map.get("keys");String json = mapper.writeValueAsString(keys.get(0));// Build key pair and validate tokenKeyPair rsaKeyPair = JWKHelper.buildRSAKeyPairFromJwk(json);jwtAuthenticator.addSignatureConfiguration(new RSASignatureConfiguration(rsaKeyPair));CommonProfile profile = jwtAuthenticator.validateToken(token);credentials.setUserProfile(profile);System.out.println("Hello, " + profile.getId());} catch (IOException e) {System.err.println("Failed to validate Bearer token: " + e.getMessage());e.printStackTrace();}}});final Clients clients = new Clients("http://localhost:8080/callback",oidcClient, headerClient, new AnonymousClient());return new Config(clients);} }

如果oidcClient的代碼中的oidcClient嘗試直接訪問您的API，則將使用戶登錄Okta。 headerClient設置了一個資源服務器，該資源服務器根據用戶的訪問令牌對用戶進行授權。

創建src/main/webapp/WEB-INF/web.xml來映射CorsFilter以及Pac4j的CallbackFilter和SecurityFilter 。您可以看到SecurityFilter通過其configFactory init-param鏈接到SecurityConfigFactory類。

<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"version="3.1"><display-name>javaee-pac4j-demo</display-name><absolute-ordering/><filter-mapping><filter-name>corsFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><filter><filter-name>callbackFilter</filter-name><filter-class>org.pac4j.j2e.filter.CallbackFilter</filter-class><init-param><param-name>defaultUrl</param-name><param-value>/</param-value></init-param><init-param><param-name>renewSession</param-name><param-value>true</param-value></init-param><init-param><param-name>multiProfile</param-name><param-value>true</param-value></init-param></filter><filter-mapping><filter-name>callbackFilter</filter-name><url-pattern>/callback</url-pattern><dispatcher>REQUEST</dispatcher></filter-mapping><filter><filter-name>OidcFilter</filter-name><filter-class>org.pac4j.j2e.filter.SecurityFilter</filter-class><init-param><param-name>configFactory</param-name><param-value>com.okta.developer.SecurityConfigFactory</param-value></init-param><init-param><param-name>clients</param-name><param-value>oidcClient,headerClient</param-value></init-param><init-param><param-name>authorizers</param-name><param-value>securityHeaders</param-value></init-param></filter><filter-mapping><filter-name>OidcFilter</filter-name><url-pattern>/*</url-pattern><dispatcher>REQUEST</dispatcher><dispatcher>FORWARD</dispatcher></filter-mapping> </web-app>

為了更好地可視化用戶信息，您需要再創建一些文件。這些與JSF相關的文件是從j2e-pac4j-cdi-demo復制的。

注意：我試圖在TomEE上運行j2e-pac4j-cdi-demo （沒有web.xml ），但是它失敗并出現錯誤： Filters cannot be added to context [] as the context has been initialised 。當使用Payara Maven插件時，它確實起作用。

創建src/main/java/com/okta/developer/ProfileView.java ，這是一個JSF托管的bean，用于收集用戶的信息。

package com.okta.developer;import org.pac4j.core.context.WebContext; import org.pac4j.core.profile.ProfileManager; import org.slf4j.Logger; import org.slf4j.LoggerFactory;import javax.annotation.PostConstruct; import javax.enterprise.context.RequestScoped; import javax.inject.Inject; import javax.inject.Named; import java.util.List;/*** Managed bean which exposes the pac4j profile manager.** JSF views such as facelets can reference this to view the contents of profiles.** @author Phillip Ross*/ @Named @RequestScoped public class ProfileView {/** The static logger instance. */private static final Logger logger = LoggerFactory.getLogger(ProfileView.class);/** The pac4j web context. */@Injectprivate WebContext webContext;/** The pac4j profile manager. */@Injectprivate ProfileManager profileManager;/** Simple no-args constructor. */public ProfileView() {}/*** Gets the first profile (if it exists) contained in the profile manager.** @return a list of pac4j profiles*/public Object getProfile() {return profileManager.get(true).orElse(null); // It's fine to return a null reference if there is no value present.}/*** Gets the profiles contained in the profile manager.** @return a list of pac4j profiles*/public List getProfiles() {return profileManager.getAll(true);}/** Simply prints some debugging information post-construction. */@PostConstructpublic void init() {logger.debug("webContext is null? {}", (webContext == null));logger.debug("profileManager is null? {}", (profileManager == null));} }

將src/main/webapp/oidc/index.xhtml為JSF模板。

<ui:composition xmlns="http://www.w3.org/1999/xhtml"xmlns:h="http://java.sun.com/jsf/html"xmlns:f="http://java.sun.com/jsf/core"xmlns:ui="http://java.sun.com/jsf/facelets"template="/WEB-INF/template.xhtml"><ui:define name="title">Pac4J Java EE Demo - Protected Area</ui:define><ui:define name="content"><div class="ui-g"><div class="ui-g-12"><div class="ui-container"><h1>Protected Area</h1><p><h:link value="Back" outcome="/index"/></p></div><ui:include src="/WEB-INF/facelets/includes/pac4j-profiles-list.xhtml"/></div></div></ui:define> </ui:composition>

創建pac4j-profiles-list.xhtml文件，該文件包含在WEB-INF/facelets/includes 。

<ui:composition xmlns="http://www.w3.org/1999/xhtml"xmlns:h="http://java.sun.com/jsf/html"xmlns:f="http://java.sun.com/jsf/core"xmlns:ui="http://java.sun.com/jsf/facelets"><div class="ui-container"><p>Found <h:outputText value="#{profileView.profiles.size()}"/> profiles.</p><h:panelGroup layout="block" rendered="#{profileView.profiles.size() > 0}"><p>First profile: <h:outputText value="#{profileView.profile}"/></p></h:panelGroup></div><h:panelGroup layout="block" rendered="#{not empty profileView.profile}"><h2>Profile Details</h2><p><h:outputText value="Id: #{profileView.profile.id}"/></p><p><h:outputText value="Type Id: #{profileView.profile.typedId}"/></p><p><h:outputText value="Remembered: #{profileView.profile.remembered}"/></p><h3>Attributes (<h:outputText value="#{profileView.profile.attributes.size()}"/>)</h3><h:panelGroup layout="block" rendered="#{profileView.profile.attributes.size() > 0}"><ul><ui:repeat value="#{profileView.profile.attributes.keySet().toArray()}" var="attributeName"><li><h:outputText value="#{attributeName}"/>: <h:outputText value="#{profileView.profile.attributes.get(attributeName)}"/> </li></ui:repeat></ul></h:panelGroup><h3>Roles (<h:outputText value="#{profileView.profile.roles.size()}"/>)</h3><h:panelGroup layout="block" rendered="#{profileView.profile.roles.size() > 0}"><ul><ui:repeat value="#{profileView.profile.roles.toArray()}" var="role"><li><h:outputText value="#{role}"/></li></ui:repeat></ul></h:panelGroup><h3>Permissions (<h:outputText value="#{profileView.profile.permissions.size()}"/>)</h3><h:panelGroup layout="block" rendered="#{profileView.profile.permissions.size() > 0}"><ul><ui:repeat value="#{profileView.profile.permissions.toArray()}" var="permission"><li><h:outputText value="#{permission}"/></li></ui:repeat></ul></h:panelGroup></h:panelGroup> </ui:composition>

oidc/index.xhtml模板使用WEB-INF/template.xhtml ，因此您也需要創建它。

<!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"xmlns:h="http://java.sun.com/jsf/html"xmlns:f="http://java.sun.com/jsf/core"xmlns:ui="http://java.sun.com/jsf/facelets"><h:head><f:facet name="first"><meta http-equiv="X-UA-Compatible" content="IE=edge" /><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0"/><meta name="apple-mobile-web-app-capable" content="yes" /></f:facet><title><ui:insert name="title">Pac4J Java EE Demo</ui:insert></title><ui:insert name="head"/></h:head><h:body styleClass="main-body"><div class="layout-wrapper"><div class="layout-main"><ui:insert name="content"/></div></div></h:body> </html>

添加這些文件后，重建項目并重新啟動TomEE。

mvn clean package tomee:run

導航到http://localhost:8080/oidc/index.jsf ，您將被重定向到Okta進行登錄。如果您初次嘗試無法解決問題，請重新啟動瀏覽器并使用隱身窗口。您應該看到用戶的個人資料信息。

在http://localhost:3000嘗試您的React客戶端; 它也應該工作！

如果您想知道為什么不堆疊圖像，那是因為我將React應用程序的BeerList.tsx的啤酒清單的JSX更改為內聯。

<h2>Beer List</h2> {beers.map((beer: Beer) =><span key={beer.id} style={{float: 'left', marginRight: '10px', marginLeft: '10px'}}>{beer.name}<br/><GiphyImage name={beer.name}/></span> )}

雅加達EE呢？

您可能已經聽說Java EE已經成為開源的（類似于Java SE的OpenJDK ），它的新名稱是Jakarta EE 。 David Blevins是一個很好的朋友，并且積極參與Java EE / Jakarta EE。有關證明，請參閱他的Twitter傳記：Apache TomEE，OpenEJB和Geronimo項目的創始人。 Apache，JCP EC，EE4J PMC，Jakarta EE WG，MicroProfile和Eclipse Board的成員。首席執行官@Tomitribe 。

我問戴維何時會發布可用的Jakarta EE。

David：目前的主要重點是創建與Java EE 8兼容的Jakarta EE版本。我們希望在今年年底之前將其發布。發布之后，我們將開始開發Jakarta EE 9并根據需要進行迭代。

Jakarta EE有一個工作組來決定平臺的方向。

了解有關安全REST API，Java EE，Jakarta EE和OIDC的更多信息

我希望您喜歡這個游覽，向您展示了如何使用JWT和OIDC構建和保護Java EE REST API。如果您想查看每個完成部分的源代碼，我將它們放在GitHub repo的分支中。您可以使用以下命令克隆不同的實現：

git clone -b jwt-verifier https://github.com/oktadeveloper/okta-java-ee-rest-api-example.git git clone -b spring-security https://github.com/oktadeveloper/okta-java-ee-rest-api-example.git git clone -b pac4j https://github.com/oktadeveloper/okta-java-ee-rest-api-example.git

如前所述，我們在此博客上獲得的大多數Java教程都展示了如何使用Spring Boot。如果您對學習Spring Boot感興趣，這里有一些我寫的教程將向您展示要點。

Spring Boot，OAuth 2.0和Okta入門
使用React和Spring Boot構建一個簡單的CRUD應用
使用Angular 7.0和Spring Boot 2.1構建基本的CRUD應用

如果您是OIDC的新手，建議您查看以下文章：

Spring Security 5.0和OIDC入門
身份，聲明和令牌– OpenID Connect入門，第1部分，共3部分
行動中的OIDC – OpenID Connect入門，第2部分，共3部分
令牌中有什么？ – OpenID Connect入門，第3部分，共3部分

有關Java REST API和TomEE的更多信息，我建議以下來源：

David Blevins –解構REST安全，迭代2018
Antonio Goncalves –使用JWT保護JAX-RS端點
TomEE：使用Systemd運行

如果您已經做到了這一點，我懷疑您可能會對將來的博客文章感興趣。在Twitter上關注我和我的整個團隊，在Facebook上關注我們，或者查看我們的YouTube頻道。如有疑問，請在下面發表評論，或將其發布到我們的開發者論壇。

使用Java EE和OIDC構建Java REST API最初于2018年9月12日發布在Okta開發人員博客上。

翻譯自: https://www.javacodegeeks.com/2018/10/build-java-rest-api-java-ee-oidc.html