使用Eclipse MicroProfile（更新版）构建您的下一个微服务

java -jar payara-micro.jar application.war

<dependency>
  <groupId>org.eclipse.microprofile</groupId>
  <artifactId>microprofile</artifactId>
  <version>1.3</version>
  <type>pom</type>
  <scope>provided</scope>
</dependency>

dependencies {  providedCompile 'org.eclipse.microprofile:microprofile:1.3'}
}

@Path("/api/books") // just a basic JAX-RS resource
@Counted // track the number of times this endpoint is invoked
@RequestScoped
public class BooksController {
 @Inject //use CDI to inject a service
 private BookService bookService;
 @GET
 @RolesAllowed("read-books")
 // uses common annotations to declare a role required
 public Books findAll() {
  return bookService.getAll();
 }
}

@ApplicationScoped
public class BookService {
 @Inject
 // JPA is not provided out of the box, but most providers support it at
 // some level.  Worst case, create your own producer for the field
 private EntityManager entityManager;
 @Inject
 // use configuration to control how much data you want to supply at
 // a given time
 @ConfigProperty(name = "max.books.per.page", defaultValue = "20")
 private int maxBooks;
 public Books getAll() {
  List < Book > bookList = entityManager
   .createQuery("select b from Book b", Book.class)
   .setMaxResults(maxBooks) // use that configuration to do a paginated look up
   .getResultList();
  return new Books(bookList);
 }
}

@Inject
@ConfigProperty
private int maxBooks

@Inject
 private JsonWebToken jsonWebToken;

  boolean createAny = jsonWebToken.getClaim("create.books.for.other.authors");
   if (!createAny) {
      throw new NotAuthorizedException("Cannot create book, wrong author");
   }

@RequestScoped
public class PublishBookService {
 @Inject
 // we can inject a JsonWebToken, a Principal specific to the JWT specification
 private JsonWebToken jsonWebToken;
 // we could also inject individual ClaimValue objects.
 @Inject
 private AuthorService authorService;
 @Inject
 private EntityManager entityManager;
 @Timeout(500)
 // we want to limit how long it takes to publish and if it
 // exceeds, return an exception to the caller.
 public BookId publish(PublishBook publishBook) {
  // we check the standard claim of subject
  if (!publishBook.getAuthor().equals(jsonWebToken.getSubject())) {
   // as well as a custom claim as a boolean
   boolean createAny = jsonWebToken.getClaim("create.books.for.other.authors");
   if (!createAny) {
    throw new NotAuthorizedException("Cannot create book, wrong author");
   }
  }
  Author author = authorService.findAuthor(publishBook.getAuthor());
  if (author == null) {
    throw new NotAuthorizedException("The list author is not an author");
  }
  Book book = entityManager.merge(new Book(publishBook.getIsbn(),
                                           publishBook.getAuthor()));
  return new BookId(book.getIsbn(), book.getAuthor());
 }
}

@LoginConfig(authMethod = "MP-JWT", realmName = "admin-realm")
@ApplicationScoped
@ApplicationPath("/")
public class BookServiceConfig extends javax.ws.rs.Application {
}

@ApplicationScoped
public class AuthorService {
 @Inject
 @RestClient
 AuthorConnector authorConnector;
 // inject a REST proxy for a URL given by a generated config property
 private ConcurrentMap < String, Author > authorCache = new ConcurrentHashMap < > ();
 @Retry
 // Retry indicates that this should trigger retry the method call several times in case the remote server call results in an exception
 @CircuitBreaker
 // CircuiBreaker wraps the call in a circuit breaker which opens after several failures and closes again after some time
 @Fallback(fallbackMethod = "getCachedAuthor")
 // Fallback indicates that we should fall back to the local cache
 // if the method fails even after several retries
 // or the circuit is open
 public Author findAuthor(String id) {
  // call to an external Author service
  Author author = authorConnector.get(id); 
  // Ideally we want to read from the remote server. 
  // However, we can build
  // a cache as a fallback when the server is down
  authorCache.put(id, author);
  return author;
 }
 public Author getCachedAuthor(String id) {
  return authorCache.get(id);
 }
}

{
    "base": {
        "classloader.totalLoadedClass.count": 16987,
        "cpu.systemLoadAverage": 1.22,
        "thread.count": 141,
        "classloader.currentLoadedClass.count": 16986,
        "jvm.uptime": 52955,
        "memory.committedNonHeap": 131727360,
        "gc.PS MarkSweep.count": 3,
        "memory.committedHeap": 503316480,
        "thread.max.count": 143,
        "gc.PS Scavenge.count": 20,
        "cpu.availableProcessors": 8,
        "thread.daemon.count": 123,
        "classloader.totalUnloadedClass.count": 2,
        "memory.usedNonHeap": 117340624,
        "memory.maxHeap": 503316480,
        "memory.usedHeap": 139449848,
        "gc.PS MarkSweep.time": 428,
        "memory.maxNonHeap": -1,
        "gc.PS Scavenge.time": 220
    }
}