JarCastingJava 8
Relocation (java-8)
nl.talsmasoftware : context-propagation-java8Standardized context propagation in concurrent systems.
Последняя версия: 1.0.9
Дата:djdbc-java8
com.github.nikita-volkov.java : djdbc-java8Integration of DJDBC with the Java 1.8 libraries
Последняя версия: 1.1
Дата:Spring Configuration Validation Processor for Java 8 Runtimes
com.github.pellaton.config-validation-processor : config-validation-processor-java8A Java 8 annotation processor to validate Spring @Configuration classes
Последняя версия: 3.0.8
Дата:jadex-applications-java8
org.activecomponents.jadex : jadex-applications-java8The Jadex applications Java 8 package contains several example applications using Java 8 language features.
Последняя версия: 3.0.117
Дата:Последняя версия: 1.0.12
Дата:Apache Beam :: SDKs :: Java :: Java 8 Tests
org.apache.beam : beam-sdks-java-java8testsApache Beam Java SDK provides a simple, Java-based interface for processing virtually any size data. This artifact includes tests of the SDK from a Java 8 user.
Последняя версия: 2.3.0
Дата:Apache Beam :: SDKs :: Java :: Maven Archetypes :: Examples - Java 8
org.apache.beam : beam-sdks-java-maven-archetypes-examples-java8A Maven Archetype to create a project containing example pipelines from the Apache Beam Java SDK, targeting Java 8.
Последняя версия: 2.2.0
Дата:Camel :: Archetypes :: Java8 Router
org.apache.camel.archetypes : camel-archetype-java8Creates a new Camel project using Java8 DSL.
Последняя версия: 3.3.0
Дата:Cucumber-JVM: Java8
com.github.slaout.fork.info.cukesthreads : cucumber-java8Sonatype helps open source projects to set up Maven repositories on https://oss.sonatype.org/
Последняя версия: 1.2.4
Дата:
Последняя версия: 1.5.3
Дата:jdbc-perf-logger-java8-tests
com.github.sylvainlaurent.jdbcperflogger : jdbc-perf-logger-java8-testsParent/Reactor project for JDBC Performance Logger
Последняя версия: 0.7.0
Дата:Camel :: Example :: Java8
org.apache.camel : camel-example-java8An example for showing Camel DSL for Java 8
Последняя версия: 2.19.5
Дата:Camel :: Example :: Java8 :: RX
org.apache.camel : camel-example-java8-rxAn example for showing Camel RX for Java 8
Последняя версия: 2.19.5
Дата:Последняя версия: 1.2
Дата:com.github.toto-castaldi:java8-web
com.github.toto-castaldi : java8-webMain pom for webapp on java 8 module
Последняя версия: 1.2
Дата:
flink-java8
org.apache.flink : flink-java8The Apache Software Foundation provides support for the Apache community of open-source software projects. The Apache projects are characterized by a collaborative, consensus based development process, an open and pragmatic software license, and a desire to create high quality software that leads the way in its field. We consider ourselves not simply a group of projects sharing a server, but rather a community of developers and users.
Последняя версия: 0.10.1-hadoop1
Дата:
flink-java8
org.apache.flink : flink-java8_2.11The Apache Software Foundation provides support for the Apache community of open-source software projects. The Apache projects are characterized by a collaborative, consensus based development process, an open and pragmatic software license, and a desire to create high quality software that leads the way in its field. We consider ourselves not simply a group of projects sharing a server, but rather a community of developers and users.
Последняя версия: 0.10.1
Дата:Genesis Flava :: Java 8
org.apache.geronimo.genesis : genesis-java8-flavaGenesis provides build support for Apache Geronimo's Maven projects.
Последняя версия: 2.4
Дата:
Adapter: Java 8
io.github.zawn : adapter-java8A Retrofit CallAdapter for Java 8's CompletableFuture.
Последняя версия: 2.10.2
Дата:
Последняя версия: 2.10.2
Дата:Последняя версия: 1.1
Дата:
Последняя версия: 2.1.0
Дата:Adapter: Java 8
io.github.zawn.retrofit2 : adapter-java8A Retrofit CallAdapter for Java 8's CompletableFuture.
Последняя версия: 2.10.6
Дата:Converter: Java 8
io.github.zawn.retrofit2 : converter-java8A Retrofit Converter for Java 8's Optional type.
Последняя версия: 2.10.6
Дата:Последняя версия: 2.10.4
Дата:
Последняя версия: 3.1.0
Дата:Последняя версия: 1.3
Дата:restx-jongo-java8
io.restx : restx-jongo-java8Sonatype helps open source projects to set up Maven repositories on https://oss.sonatype.org/
Последняя версия: 0.35.1
Дата:restx-samplest-java8
io.restx : restx-samplest-java8Sonatype helps open source projects to set up Maven repositories on https://oss.sonatype.org/
Последняя версия: 0.35.1
Дата:com.github.hullbend:dynahist-java8
com.github.hullbend : dynahist-java8DynaHist-Java8: A Dynamic Histogram Library for Java 8+
Последняя версия: 1.1.1
Дата:
Cirneco's Hamcrest Extensions for JDK8
it.ozimov : java8-hamcrest-matchersAn extension to make unit test easier with Hamcrest and Java8.
Последняя версия: 1.3.0
Дата:ModelMapper Module Java8
com.github.chhsiao90 : modelmapper-module-java8ModelMapper Module for Java8
Последняя версия: 1.2.1
Дата:ModelMapper Module Java8 Data Types
com.github.chhsiao90 : modelmapper-module-java8-datatypesModelMapper Module for Java8 Data Types
Последняя версия: 1.2.1
Дата:Последняя версия: 0.2
Дата:java8-jersey2-guice4-webapp-archetype
me.thingle.archetypes : java8-jersey2-guice4-webapp-archetypeA java 8, servlet 3.1 webapp with jersey 2 and guice 4
Последняя версия: 1.1.0
Дата:Array Hash Tools
com.github.fedorov-s-n.aht : aht-java8Concurrent lock-free collections with O(1) access time
Последняя версия: 1.0
Дата:Последняя версия: 1.0.0
Дата:tile-java8
io.featurehub.sdk.tiles : tile-java8tile java contains plugins required for java application creation. It is focused on Java 8 and is designed to allow us to side-load plugins in a consistent fashion across the java-sdk without repeating ourselves.
Последняя версия: 1.1
Дата:
Последняя версия: 2.18.0
Дата:
Последняя версия: 0.0.6.OSS
Дата:OSSParent
cn.songxinqiang : oss-parent-java8This is the common settings for maven projects to publish to Maven Central Repository,artifacts extend from this one can publish to the repo without any setting.
Последняя версия: 1.0
Дата:Последняя версия: 0.2.0
Дата:Последняя версия: 1.2.2
Дата:ModelMapper Module Java8 Data Types
org.modelmapper : modelmapper-module-java8-datatypesModelMapper Module for Java8 Data Types
Последняя версия: 1.2.2
Дата:
JAXB Type Adapters for java.time
com.addicticks.jaxb : java8datetimeProvides JAXB XmlAdapters for fluent working with date and time values.
Последняя версия: 1.0.1
Дата:
JAXB Type Adapters for java.time
com.addicticks.oss.jaxb : java8datetimeProvides JAXB XmlAdapters for fluent working with date and time values.
Последняя версия: 1.0.2
Дата:
java8
au.com.dius.pact.consumer : java8# pact-jvm-consumer-java8 Provides a Java8 lambda based DSL for use with Junit to build consumer tests. ## Dependency The library is available on maven central using: * group-id = `au.com.dius.pact.consumer` * artifact-id = `java8` * version-id = `4.1.x` # A Lambda DSL for Pact This is an extension for the pact DSL provided by [consumer](../consumer). The difference between the default pact DSL and this lambda DSL is, as the name suggests, the usage of lambdas. The use of lambdas makes the code much cleaner. ## Why a new DSL implementation? The lambda DSL solves the following two main issues. Both are visible in the following code sample: ```java new PactDslJsonArray() .array() # open an array .stringValue("a1") # choose the method that is valid for arrays .stringValue("a2") # choose the method that is valid for arrays .closeArray() # close the array .array() # open an array .numberValue(1) # choose the method that is valid for arrays .numberValue(2) # choose the method that is valid for arrays .closeArray() # close the array .array() # open an array .object() # now we work with an object .stringValue("foo", "Foo") # choose the method that is valid for objects .closeObject() # close the object and we're back in the array .closeArray() # close the array ``` ### The existing DSL is quite error-prone Methods may only be called in certain states. For example `object()` may only be called when you're currently working on an array whereas `object(name)` is only allowed to be called when working on an object. But both of the methods are available. You'll find out at runtime if you're using the correct method. Finally, the need for opening and closing objects and arrays makes usage cumbersome. The lambda DSL has no ambiguous methods and there's no need to close objects and arrays as all the work on such an object is wrapped in a lamda call. ### The existing DSL is hard to read When formatting your source code with an IDE the code becomes hard to read as there's no indentation possible. Of course, you could do it by hand but we want auto formatting! Auto formatting works great for the new DSL! ```java array.object((o) -> { o.stringValue("foo", "Foo"); # an attribute o.stringValue("bar", "Bar"); # an attribute o.object("tar", (tarObject) -> { # an attribute with a nested object tarObject.stringValue("a", "A"); # attribute of the nested object tarObject.stringValue("b", "B"); # attribute of the nested object }) }); ``` ## Installation ### Maven ``` <dependency> <groupId>au.com.dius.pact.consumer</groupId> <artifactId>java8</artifactId> <version>${pact.version}</version> </dependency> ``` ## Usage Start with a static import of `LambdaDsl`. This class contains factory methods for the lambda dsl extension. When you come accross the `body()` method of `PactDslWithProvider` builder start using the new extensions. The call to `LambdaDsl` replaces the call to instance `new PactDslJsonArray()` and `new PactDslJsonBody()` of the pact library. ```java io.pactfoundation.consumer.dsl.LambdaDsl.* ``` ### Response body as json array ```java import static io.pactfoundation.consumer.dsl.LambdaDsl.newJsonArray; ... PactDslWithProvider builder = ... builder.given("some state") .uponReceiving("a request") .path("/my-app/my-service") .method("GET") .willRespondWith() .status(200) .body(newJsonArray((a) -> { a.stringValue("a1"); a.stringValue("a2"); }).build()); ``` ### Response body as json object ```java import static io.pactfoundation.consumer.dsl.LambdaDsl.newJsonBody; ... PactDslWithProvider builder = ... builder.given("some state") .uponReceiving("a request") .path("/my-app/my-service") .method("GET") .willRespondWith() .status(200) .body(newJsonBody((o) -> { o.stringValue("foo", "Foo"); o.stringValue("bar", "Bar"); }).build()); ``` ### Examples #### Simple Json object When creating simple json structures the difference between the two approaches isn't big. ##### JSON ```json { "bar": "Bar", "foo": "Foo" } ``` ##### Pact DSL ```java new PactDslJsonBody() .stringValue("foo", "Foo") .stringValue("bar", "Bar") ``` ##### Lambda DSL ```java newJsonBody((o) -> { o.stringValue("foo", "Foo"); o.stringValue("bar", "Bar"); }).build(); ``` #### An array of arrays When we come to more complex constructs with arrays and nested objects the beauty of lambdas become visible! ##### JSON ```json [ ["a1", "a2"], [1, 2], [{"foo": "Foo"}] ] ``` ##### Pact DSL ```java new PactDslJsonArray() .array() .stringValue("a1") .stringValue("a2") .closeArray() .array() .numberValue(1) .numberValue(2) .closeArray() .array() .object() .stringValue("foo", "Foo") .closeObject() .closeArray(); ``` ##### Lambda DSL ```java newJsonArray((rootArray) -> { rootArray.array((a) -> a.stringValue("a1").stringValue("a2")); rootArray.array((a) -> a.numberValue(1).numberValue(2)); rootArray.array((a) -> a.object((o) -> o.stringValue("foo", "Foo"))); }).build(); ``` ##### Kotlin Lambda DSL ```kotlin newJsonArray { newArray { stringValue("a1") stringValue("a2") } newArray { numberValue(1) numberValue(2) } newArray { newObject { stringValue("foo", "Foo") } } } ``` # Test Analytics We are tracking anonymous analytics to gather important usage statistics like JVM version and operating system. To disable tracking, set the 'pact_do_not_track' system property or environment variable to 'true'.
Последняя версия: 4.1.38
Дата:
pact-jvm-consumer-java8
au.com.dius : pact-jvm-consumer-java8# pact-jvm-consumer-java8 Provides a Java8 lambda based DSL for use with Junit to build consumer tests. # A Lambda DSL for Pact This is an extension for the pact DSL provided by [pact-jvm-consumer](../pact-jvm-consumer). The difference between the default pact DSL and this lambda DSL is, as the name suggests, the usage of lambdas. The use of lambdas makes the code much cleaner. ## Why a new DSL implementation? The lambda DSL solves the following two main issues. Both are visible in the following code sample: ```java new PactDslJsonArray() .array() # open an array .stringValue("a1") # choose the method that is valid for arrays .stringValue("a2") # choose the method that is valid for arrays .closeArray() # close the array .array() # open an array .numberValue(1) # choose the method that is valid for arrays .numberValue(2) # choose the method that is valid for arrays .closeArray() # close the array .array() # open an array .object() # now we work with an object .stringValue("foo", "Foo") # choose the method that is valid for objects .closeObject() # close the object and we're back in the array .closeArray() # close the array ``` ### The existing DSL is quite error-prone Methods may only be called in certain states. For example `object()` may only be called when you're currently working on an array whereas `object(name)` is only allowed to be called when working on an object. But both of the methods are available. You'll find out at runtime if you're using the correct method. Finally, the need for opening and closing objects and arrays makes usage cumbersome. The lambda DSL has no ambiguous methods and there's no need to close objects and arrays as all the work on such an object is wrapped in a lamda call. ### The existing DSL is hard to read When formatting your source code with an IDE the code becomes hard to read as there's no indentation possible. Of course, you could do it by hand but we want auto formatting! Auto formatting works great for the new DSL! ```java array.object((o) -> { o.stringValue("foo", "Foo"); # an attribute o.stringValue("bar", "Bar"); # an attribute o.object("tar", (tarObject) -> { # an attribute with a nested object tarObject.stringValue("a", "A"); # attribute of the nested object tarObject.stringValue("b", "B"); # attribute of the nested object }) }); ``` ## Installation ### Maven ``` <dependency> <groupId>au.com.dius</groupId> <artifactId>pact-jvm-consumer-java8_2.12</artifactId> <version>${pact.version}</version> </dependency> ``` ## Usage Start with a static import of `LambdaDsl`. This class contains factory methods for the lambda dsl extension. When you come accross the `body()` method of `PactDslWithProvider` builder start using the new extensions. The call to `LambdaDsl` replaces the call to instance `new PactDslJsonArray()` and `new PactDslJsonBody()` of the pact library. ```java io.pactfoundation.consumer.dsl.LambdaDsl.* ``` ### Response body as json array ```java import static io.pactfoundation.consumer.dsl.LambdaDsl.newJsonArray; ... PactDslWithProvider builder = ... builder.given("some state") .uponReceiving("a request") .path("/my-app/my-service") .method("GET") .willRespondWith() .status(200) .body(newJsonArray((a) -> { a.stringValue("a1"); a.stringValue("a2"); }).build()); ``` ### Response body as json object ```java import static io.pactfoundation.consumer.dsl.LambdaDsl.newJsonBody; ... PactDslWithProvider builder = ... builder.given("some state") .uponReceiving("a request") .path("/my-app/my-service") .method("GET") .willRespondWith() .status(200) .body(newJsonBody((o) -> { o.stringValue("foo", "Foo"); o.stringValue("bar", "Bar"); }).build()); ``` ### Examples #### Simple Json object When creating simple json structures the difference between the two approaches isn't big. ##### JSON ```json { "bar": "Bar", "foo": "Foo" } ``` ##### Pact DSL ```java new PactDslJsonBody() .stringValue("foo", "Foo") .stringValue("bar", "Bar") ``` ##### Lambda DSL ```java newJsonBody((o) -> { o.stringValue("foo", "Foo"); o.stringValue("bar", "Bar"); }).build(); ``` #### An array of arrays When we come to more complex constructs with arrays and nested objects the beauty of lambdas become visible! ##### JSON ```json [ ["a1", "a2"], [1, 2], [{"foo": "Foo"}] ] ``` ##### Pact DSL ```java new PactDslJsonArray() .array() .stringValue("a1") .stringValue("a2") .closeArray() .array() .numberValue(1) .numberValue(2) .closeArray() .array() .object() .stringValue("foo", "Foo") .closeObject() .closeArray(); ``` ##### Lambda DSL ```java newJsonArray((rootArray) -> { rootArray.array((a) -> a.stringValue("a1").stringValue("a2")); rootArray.array((a) -> a.numberValue(1).numberValue(2)); rootArray.array((a) -> a.object((o) -> o.stringValue("foo", "Foo"))); }).build(); ``` ##### Kotlin Lambda DSL ```kotlin newJsonArray { newArray { stringValue("a1") stringValue("a2") } newArray { numberValue(1) numberValue(2) } newArray { newObject { stringValue("foo", "Foo") } } } ```
Последняя версия: 4.0.10
Дата:
pact-jvm-consumer-java8_2.11
au.com.dius : pact-jvm-consumer-java8_2.11# pact-jvm-consumer-java8 Provides a Java8 lambda based DSL for use with Junit to build consumer tests. # A Lambda DSL for Pact This is an extension for the pact DSL provided by [pact-jvm-consumer](../pact-jvm-consumer). The difference between the default pact DSL and this lambda DSL is, as the name suggests, the usage of lambdas. The use of lambdas makes the code much cleaner. ## Why a new DSL implementation? The lambda DSL solves the following two main issues. Both are visible in the following code sample: ```java new PactDslJsonArray() .array() # open an array .stringValue("a1") # choose the method that is valid for arrays .stringValue("a2") # choose the method that is valid for arrays .closeArray() # close the array .array() # open an array .numberValue(1) # choose the method that is valid for arrays .numberValue(2) # choose the method that is valid for arrays .closeArray() # close the array .array() # open an array .object() # now we work with an object .stringValue("foo", "Foo") # choose the method that is valid for objects .closeObject() # close the object and we're back in the array .closeArray() # close the array ``` ### The existing DSL is quite error-prone Methods may only be called in certain states. For example `object()` may only be called when you're currently working on an array whereas `object(name)` is only allowed to be called when working on an object. But both of the methods are available. You'll find out at runtime if you're using the correct method. Finally, the need for opening and closing objects and arrays makes usage cumbersome. The lambda DSL has no ambiguous methods and there's no need to close objects and arrays as all the work on such an object is wrapped in a lamda call. ### The existing DSL is hard to read When formatting your source code with an IDE the code becomes hard to read as there's no indentation possible. Of course, you could do it by hand but we want auto formatting! Auto formatting works great for the new DSL! ```java array.object((o) -> { o.stringValue("foo", "Foo"); # an attribute o.stringValue("bar", "Bar"); # an attribute o.object("tar", (tarObject) -> { # an attribute with a nested object tarObject.stringValue("a", "A"); # attribute of the nested object tarObject.stringValue("b", "B"); # attribute of the nested object }) }); ``` ## Installation ### Maven ``` <dependency> <groupId>au.com.dius</groupId> <artifactId>pact-jvm-consumer-java8_2.12</artifactId> <version>${pact.version}</version> </dependency> ``` ## Usage Start with a static import of `LambdaDsl`. This class contains factory methods for the lambda dsl extension. When you come accross the `body()` method of `PactDslWithProvider` builder start using the new extensions. The call to `LambdaDsl` replaces the call to instance `new PactDslJsonArray()` and `new PactDslJsonBody()` of the pact library. ```java io.pactfoundation.consumer.dsl.LambdaDsl.* ``` ### Response body as json array ```java import static io.pactfoundation.consumer.dsl.LambdaDsl.newJsonArray; ... PactDslWithProvider builder = ... builder.given("some state") .uponReceiving("a request") .path("/my-app/my-service") .method("GET") .willRespondWith() .status(200) .body(newJsonArray((a) -> { a.stringValue("a1"); a.stringValue("a2"); }).build()); ``` ### Response body as json object ```java import static io.pactfoundation.consumer.dsl.LambdaDsl.newJsonBody; ... PactDslWithProvider builder = ... builder.given("some state") .uponReceiving("a request") .path("/my-app/my-service") .method("GET") .willRespondWith() .status(200) .body(newJsonBody((o) -> { o.stringValue("foo", "Foo"); o.stringValue("bar", "Bar"); }).build()); ``` ### Examples #### Simple Json object When creating simple json structures the difference between the two approaches isn't big. ##### JSON ```json { "bar": "Bar", "foo": "Foo" } ``` ##### Pact DSL ```java new PactDslJsonBody() .stringValue("foo", "Foo") .stringValue("bar", "Bar") ``` ##### Lambda DSL ```java newJsonBody((o) -> { o.stringValue("foo", "Foo"); o.stringValue("bar", "Bar"); }).build() ``` #### An array of arrays When we come to more complex constructs with arrays and nested objects the beauty of lambdas become visible! ##### JSON ```json [ ["a1", "a2"], [1, 2], [{"foo": "Foo"}] ] ``` ##### Pact DSL ```java new PactDslJsonArray() .array() .stringValue("a1") .stringValue("a2") .closeArray() .array() .numberValue(1) .numberValue(2) .closeArray() .array() .object() .stringValue("foo", "Foo") .closeObject() .closeArray() ``` ##### Lambda DSL ```java newJsonArray((rootArray) -> { rootArray.array((a) -> a.stringValue("a1").stringValue("a2")); rootArray.array((a) -> a.numberValue(1).numberValue(2)); rootArray.array((a) -> a.object((o) -> o.stringValue("foo", "Foo")); }).build() ```
Последняя версия: 3.5.24
Дата:
VRaptor4 - Java 8 plugin
br.com.caelum.vraptor : vraptor-java8Sonatype helps open source projects to set up Maven repositories on https://oss.sonatype.org/
Последняя версия: 4.0.0.Final
Дата: