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 。

<input type="hidden" value="${_csrf.token}" name="${_csrf.parameterName}"/>

重新啟動您的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 。

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() {} }

在同一程序包中創建一個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開發人員。 厭倦了一次又一次地建立相同的登錄屏幕？ 嘗試使用Okta API進行托管身份驗證，授權和多因素身份驗證。

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

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

oidc

總結

以上是生活随笔為你收集整理的oidc_使用Java EE和OIDC构建Java REST API的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。