The Java 11 HttpClient has an internal connection pool. By default, it is unlimited in size.
The JDK 11 ConnectionPool checks the jdk.httpclient.connectionPoolSize system property when initializing and defaults to 0 (unlimited).
HttpClient client = HttpClient.newBuilder().connectionPool(ConnectionPool.newBuilder().maxConnections(50).build()).build();
HttpRequest httpRequest = HttpRequest.newBuilder().uri(URI.create(basePhoneHomeUrl)).timeout(Duration.ofMillis(TIMEOUT)).POST(HttpRequest.BodyPublishers.ofString(requestBody, StandardCharsets.UTF_8)).build();try {HttpClient httpClient = HttpClient.newBuilder().connectTimeout(Duration.ofMillis(TIMEOUT)).build();httpClient.send(httpRequest, HttpResponse.BodyHandlers.discarding());} catch (Exception ignored) {...}
HttpResponse<String> postData(String jsonStr, String endpoint, String accessToken) throws Exception { HttpClient httpClient = HttpClient.newHttpClient(); HttpRequest httpRequest = HttpRequest.newBuilder() .header("Content-Type", "application/json") .header("Authorization", "Bearer " + accessToken) .uri(URI.create("https://...")) .POST(HttpRequest.BodyPublishers.ofString(jsonStr)) .build(); HttpResponse<String> httpResponse = httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofString()); return httpResponse; }
import jdk.jfr.consumer.RecordingStream;
import jdk.jfr.consumer.RecordingStream;public static void main(String[] args) {try (var rs = new RecordingStream()) {rs.onEvent("jdk.GarbageCollection", event ->System.out.format("Garbage collection: %s, duration: %dns%n", event.getEndTime(), event.getDuration()));rs.startAsync();Thread.sleep(60_000);} catch (InterruptedException e) {e.printStackTrace();}}
In this example, we create a RecordingStream, define an event handler for garbage collection events, start the stream asynchronously, and keep the application alive for 60 seconds to observe the events.
import java.net.http.HttpResponse;
import java.net.URI;import java.net.http.HttpClient;import java.net.http.HttpRequest;import java.net.http.HttpResponse;HttpClient httpClient = HttpClient.newHttpClient();HttpRequest request = HttpRequest.newBuilder().uri(URI.create("https://api.example.com/data")).GET().build();HttpResponse<String> response = httpClient .send(request, HttpResponse.BodyHandlers.ofString());System.out.println(response.statusCode());System.out.println(response.body());
// Pre-Java 11Function<String, Integer> preJava11Func = (String s) -> Integer.parseInt(s) + 10;// Java 11Function<String, Integer> java11Func = (var s) -> Integer.parseInt(s) + 10;
ÖrnekSince Java 11, java FileName.java compiles and runs FileName.java; however, compilation happens "behind the scenes", without explicitly producing corresponding .class file. Instead, it directly loads corresponding byte-code into the JVM instance.
public class Myclass {
public static void main(String[] args){
System.out.println("hello world");
}
}javac hello.java
java hello$ java hello.java
$ hello worldjava --source 21 --enable-preview MyAwesomeApp.java<dependency> <groupId>com.github.javafaker</groupId> <artifactId>javafaker</artifactId> <version>1.0.2</version> </dependency>
Faker faker = new Faker(Locale.FRANCE); String teamName = faker.team().name(); faker.address().city(); faker.address().zipCode(); faker.address().streetAddress(); faker.name().firstName(); faker.name().lastName(); faker.date().birthday(18, 38); faker.random().nextInt(0, 20) faker.random().nextBoolean()
Zero Copy is a technique employed in computer systems to minimize data copying and movement during data transfer operations. It aims to improve performance and reduce resource utilization by avoiding unnecessary data copying.
The Java class libraries support zero copy on Linux and UNIX systems through the transferTo() method in java.nio.channels.FileChannel. You can use the transferTo() method to transfer bytes directly from the channel on which it is invoked to another writable byte channel, without requiring data to flow through the application.
void fileCopyUsingNIOChannelClass() throws IOException {
File fileToCopy = new File("c:/temp/testoriginal.txt");
FileInputStream inputStream = new FileInputStream(fileToCopy);
FileChannel inChannel = inputStream.getChannel();
File newFile = new File("c:/temp/testcopied.txt");
FileOutputStream outputStream = new FileOutputStream(newFile);
FileChannel outChannel = outputStream.getChannel();
inChannel.transferTo(0, fileToCopy.length(), outChannel);
inputStream.close();
outputStream.close();
}Örnek - Dosyadan Sockete KopyalamaFileChannel nesnesinden SocketChannel nesnesine kopyalanır. Şöyle yaparız. İstemci bir sunucuya dosya gönderiyorString host = "localhost";
int port = 9026;
SocketAddress socketAddress = new InetSocketAddress(host, port);
SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(socketAddress);
socketChannel.configureBlocking(true);
String fname = ...;
long fsize = 183678375L;
FileChannel fileChannel = new FileInputStream(fname).getChannel();
long sentBytes = fileChannel.transferTo(0, fsize, socketChannel);
fileChannel.close();
<dependency><groupId>org.testcontainers</groupId> <artifactId>toxiproxy</artifactId> <version>1.18.3</version> <scope>test</scope> </dependency>
import eu.rekawek.toxiproxy.Proxy;import eu.rekawek.toxiproxy.ToxiproxyClient;import eu.rekawek.toxiproxy.model.ToxicDirection;@Testcontainerspublic class ToxiproxyExample {@Containerprivate static ToxiproxyContainer toxiproxy = new ToxiproxyContainer();@Containerprivate static PostgreSQLContainer<?> database = new PostgreSQLContainer<>("postgres:11.19-bullseye")@Rulepublic ToxiproxyClient toxiproxyClient = new ToxiproxyClient(toxiproxy.getHost(), toxiproxy.getControlPort());@Testpublic void testApplicationWithLatency() {// ToxicDirection.DOWNSTREAM is from client to DB// Create a toxic that adds 100 milliseconds of latency to the connection to the DB.toxiproxyClient.toxics().latency("database", ToxicDirection.DOWNSTREAM, 100);// Try to connect to the database.try (var connection = DriverManager.getConnection(database.getHost() + ":" + database.getMappedPort(5432), "postgres", "postgres")) {// Do something with the connection.}// Remove the toxic.toxiproxyClient.toxics().get("database").remove();}}
import java.util.concurrent.ExecutionException;
Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception. This exception can be inspected using the Throwable.getCause() method.
FutureTask futureTask = new FutureTask(() -> {
// Throw an exception to simulate an error during execution
throw new RuntimeException("An error occurred during task execution");
});
Thread thread = new Thread(futureTask);
// Start the thread
thread.start();
try {
// Wait for the thread to complete
futureTask.get();
} catch (ExecutionException e) {
System.out.println("ExecutionException");
}
... JShell was introduced in Java 9 and is available along with other JDK tools in the JDK_HOME/bin directory....To start with JShell, browse to the JDK_HOME/bin directory in a command-line /terminal and type jshell.
DEFAULT: loaded if no start-up script is specified.JAVASE: imports a lot more packages.PRINTING: like default, but adds print convenience methods.TOOLING : Java 21 ile geliyor. Bazı şeyler hazır geliyor. Hazır gelen komutlar şunlar
void jar(String... args)void javac(String... args)args)void javadoc(String... args)void javap(String... args)void jdeps(String... args)void jlink(String... args)void jmod(String... args)void jpackage(String... args)
jshell --start DEFAULT TOOLING
jshell> record Point(int x, int y) { }
jshell> javap(Point.class)
Classfile /tmp/TOOLING-11410713526801554514.class
Last modified Oct 3, 2023; size 1281 bytes
SHA-256 checksum 6f3f6c989dacd62919ce9330c7e1cc9a9511402d044198747d9a35c66a1160f4
Compiled from "$JShell$22.java"
public final class REPL.$JShell$22$Point extends java.lang.Record
minor version: 0
major version: 65
flags: (0x0031) ACC_PUBLIC, ACC_FINAL, ACC_SUPER
this_class: #8 // REPL/$JShell$22$Point
super_class: #2 // java/lang/Record
interfaces: 0, fields: 2, methods: 6, attributes: 5
Constant pool:
#1 = Methodref #2.#3 // java/lang/Record."<init>":()V
#2 = Class #4 // java/lang/Record
#3 = NameAndType #5:#6 // "<init>":()V
// ... snip ...private CompletableFuture<String> executeApiCallWithRetry(String url) {CompletableFuture<String> future = new CompletableFuture<>();executeApiCallWithRetryImpl(url, future, 0);return future;}private void executeApiCallWithRetryImpl(String url, CompletableFuture<String> future, int retryCount) {if (retryCount > MAX_RETRIES) {future.complete("Failed after maximum retries");return;}CompletableFuture.supplyAsync(() -> restTemplate.getForObject(url, String.class)).whenComplete((result, ex) -> {if (ex != null) {try {Thread.sleep(RETRY_INTERVAL_MS);} catch (InterruptedException e) {Thread.currentThread().interrupt();}executeApiCallWithRetryImpl(url, future, retryCount + 1); // Recursive call} else {future.complete(result);}});}
@Servicepublic class ApiService {@Autowiredprivate RestTemplate restTemplate;private static final int MAX_RETRIES = 3;private static final long RETRY_INTERVAL_MS = 1000;public List<String> executeParallelApiCalls() {List<String> urls = ...;List<CompletableFuture<String>> futures = urls.stream().map(url -> executeApiCallWithRetry(url)).collect(Collectors.toList()); // Wait for all operations to completeCompletableFuture<Void> allFutures = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()])); // Convert result to listCompletableFuture<List<String>> result = allFutures.thenApply(v -> futures.stream().map(future -> future.getNow("Fallback result")).collect(Collectors.toList()));List<String> resultList = result.join();return resultList;}}
// Some code
CompletableFuture<A> future= CompletableFuture.supplyAsync(() -> {
try {
return someObj.someFunc();
}
catch(ServerException ex) {
throw new CompletionException(ex);
}
});public static CompletableFuture<Integer> converter(String convertMe) {
CompletableFuture<Integer> future = new CompletableFuture<>();
try {
future.complete(Integer.parseInt(convertMe));
} catch (Exception ex) {
future.completeExceptionally(ex);
}
return future;
}CompletableFuture<A> future = ...;
A resultOfA;
try {
resultOfA = future.join();
}
catch(CompletionException ex) {
...
}CompletableFuture<A> future = ...;
A resultOfA;
try {
resultOfA = future.get();
}
catch(Exception ex) {
...
}CompletableFuture correctHandler = CompletableFuture.supplyAsync(() -> "A")
.thenApply(Integer::parseInt)
.handle((result, ex) -> {
if (null != ex) {
ex.printStackTrace();
return 0;
} else {
System.out.println("HANDLING " + result);
return result;
}
})
.thenAcceptAsync(s -> {
System.out.println("CORRECT: " + s);
});CompletableFuture parser = CompletableFuture.supplyAsync(() -> "1")
.thenApply(Integer::parseInt)
.exceptionally(t -> {
t.printStackTrace();
return 0;
})
.thenAcceptAsync(s -> System.out.println("CORRECT value: " + s));CompletableFuture correctHandler2 = CompletableFuture.supplyAsync(() -> "A")
.thenApply(Integer::parseInt)
.whenComplete((result, ex) -> {
if (null != ex) {
ex.printStackTrace();
}
})
.thenAcceptAsync(s -> {
System.out.println("When Complete: " + s);
});