{"id":4403,"date":"2025-08-09T10:34:16","date_gmt":"2025-08-09T10:34:16","guid":{"rendered":"https:\/\/uplatz.com\/blog\/?p=4403"},"modified":"2025-08-09T10:34:16","modified_gmt":"2025-08-09T10:34:16","slug":"java-pocket-book","status":"publish","type":"post","link":"https:\/\/uplatz.com\/blog\/java-pocket-book\/","title":{"rendered":"Java Pocket Book"},"content":{"rendered":"<p><!-- Java Pocket Book \u2014 Uplatz (50 Cards, Wide Layout, Readable Code, Scoped Styles) --><\/p>\n<div style=\"margin:16px 0;\">\n<style>\n    .wp-java-pb { font-family: Arial, sans-serif; max-width: 1320px; margin:0 auto; }\n    .wp-java-pb .heading{\n      background: linear-gradient(135deg, #e0f2fe, #e0f7fa); \/* lighter gradient *\/\n      color:#0f172a; padding:22px 24px; border-radius:14px;\n      text-align:center; margin-bottom:18px; box-shadow:0 8px 20px rgba(0,0,0,.08);\n      border:1px solid #cbd5e1;\n    }\n    .wp-java-pb .heading h2{ margin:0; font-size:2.1rem; letter-spacing:.2px; }\n    .wp-java-pb .heading p{ margin:6px 0 0; font-size:1.02rem; opacity:.9; }<\/p>\n<p>    \/* Wide, dense grid *\/\n    .wp-java-pb .grid{\n      display:grid; gap:14px;\n      grid-template-columns: repeat(auto-fill, minmax(400px, 1fr));\n    }\n    @media (min-width:1200px){\n      .wp-java-pb .grid{ grid-template-columns: repeat(3, 1fr); }\n    }<\/p>\n<p>    .wp-java-pb .section-title{\n      grid-column:1\/-1; background:#f8fafc; border-left:8px solid #2563eb;\n      padding:12px 16px; border-radius:10px; font-weight:700; color:#0f172a; font-size:1.08rem;\n      box-shadow:0 2px 8px rgba(0,0,0,.05); border:1px solid #e2e8f0;\n    }\n    .wp-java-pb .card{\n      background:#ffffff; border-left:6px solid #2563eb;\n      padding:18px; border-radius:12px;\n      box-shadow:0 6px 14px rgba(0,0,0,.06);\n      transition:transform .12s ease, box-shadow .12s ease;\n      border:1px solid #e5e7eb;\n    }\n    .wp-java-pb .card:hover{ transform: translateY(-3px); box-shadow:0 10px 22px rgba(0,0,0,.08); }\n    .wp-java-pb .card h3{ margin:0 0 10px; font-size:1.12rem; color:#0f172a; }\n    .wp-java-pb .card p{ margin:0; font-size:.96rem; color:#334155; line-height:1.62; }<\/p>\n<p>    \/* Color helpers *\/\n    .bg-blue { border-left-color:#2563eb !important; background:#f0f7ff !important; }\n    .bg-green{ border-left-color:#10b981 !important; background:#f0fdf4 !important; }\n    .bg-amber{ border-left-color:#f59e0b !important; background:#fffbeb !important; }\n    .bg-violet{ border-left-color:#8b5cf6 !important; background:#f5f3ff !important; }\n    .bg-rose{ border-left-color:#ef4444 !important; background:#fff1f2 !important; }\n    .bg-cyan{ border-left-color:#06b6d4 !important; background:#ecfeff !important; }\n    .bg-lime{ border-left-color:#16a34a !important; background:#f0fdf4 !important; }\n    .bg-orange{ border-left-color:#f97316 !important; background:#fff7ed !important; }\n    .bg-indigo{ border-left-color:#6366f1 !important; background:#eef2ff !important; }\n    .bg-emerald{ border-left-color:#22c55e !important; background:#ecfdf5 !important; }\n    .bg-slate{ border-left-color:#334155 !important; background:#f8fafc !important; }<\/p>\n<p>    \/* Utilities *\/\n    .tight ul{ margin:0; padding-left:18px; }\n    .tight li{ margin:4px 0; }\n    .mono{ font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; }\n    .kbd{ background:#e5e7eb; border:1px solid #cbd5e1; padding:1px 6px; border-radius:6px; font-family:ui-monospace,monospace; font-size:.88em; }\n    .muted{ color:#64748b; }\n    .wp-java-pb code{ background:#f1f5f9; padding:0 4px; border-radius:4px; border:1px solid #e2e8f0; }\n    .wp-java-pb pre{\n      background:#f5f5f5; color:#111827; border:1px solid #e5e7eb;\n      padding:12px; border-radius:8px; overflow:auto; font-size:.92rem; line-height:1.55;\n    }\n    .q{font-weight:700;}\n    .qa p{ margin:8px 0; }\n    .qa b{ color:#0f172a; }\n  <\/style>\n<div class=\"wp-java-pb\">\n<div class=\"heading\">\n<h2>Java Pocket Book \u2014 Uplatz<\/h2>\n<p>50 deep-dive cards \u2022 Wide layout \u2022 Readable code examples \u2022 20+ Interview Q&amp;A<\/p>\n<\/p><\/div>\n<div class=\"grid\">\n      <!-- =============== SECTION 1: FOUNDATIONS (1\u201310) =============== --><\/p>\n<div class=\"section-title\">Section 1 \u2014 Foundations<\/div>\n<div class=\"card bg-blue\">\n<h3>1) What is Java?<\/h3>\n<p>Java is a statically typed, object-oriented programming language running on the JVM (Java Virtual Machine). \u201cWrite once, run anywhere\u201d comes from compiling to bytecode that executes on any platform with a compatible JVM. Java emphasizes readability, backward compatibility, and robust libraries. It\u2019s widely used for enterprise backends, Android, big data, trading systems, and more. Modern Java (17\/21 LTS) adds features like records, sealed classes, pattern matching, and virtual threads.<\/p>\n<pre><code class=\"mono\">\/\/ Hello, Java\r\npublic class Main {\r\n  public static void main(String[] args) {\r\n    System.out.println(\"Hello, Java!\");\r\n  }\r\n}<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-green\">\n<h3>2) JDK vs JRE vs JVM<\/h3>\n<p><b>JVM<\/b> executes bytecode. <b>JRE<\/b> (runtime) = JVM + libraries to run apps. <b>JDK<\/b> (development kit) = JRE + compiler (javac), tools (jlink, jdeps, jpackage). Use the JDK to build; deploy with a JRE or custom runtime image via <code>jlink<\/code>. Choose a distribution (Temurin, Oracle, Amazon Corretto, Zulu) that fits your support needs.<\/p>\n<pre><code class=\"mono\">javac Main.java\r\njava Main<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-amber\">\n<h3>3) Java Release Cadence &#038; LTS<\/h3>\n<p>Java releases every 6 months; Long-Term Support (LTS) versions (e.g., 11, 17, 21) receive extended support and are recommended for production. Non-LTS are great for exploring new features early. For enterprises, standardize on an LTS and upgrade on a predictable schedule to stay secure and supported.<\/p>\n<pre><code class=\"mono\">\/\/ Check version\r\njava -version<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-violet\">\n<h3>4) JVM Architecture Basics<\/h3>\n<p>The JVM loads bytecode via the class loader, verifies it, and executes using the interpreter and JIT (C1\/C2) compilers. Memory areas include heap (objects), stacks (frames per thread), metaspace (class metadata), and code cache. Garbage collectors manage heap (G1, ZGC, Shenandoah). Understanding GC and JIT helps you tune performance.<\/p>\n<pre><code class=\"mono\">java -XX:+PrintFlagsFinal -version  \/\/ Inspect defaults<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-rose\">\n<h3>5) OOP: The Big Four<\/h3>\n<p>Encapsulation (hide data via access modifiers), Inheritance (reuse via <code>extends<\/code>), Polymorphism (same interface, different behaviors), and Abstraction (interfaces\/abstract classes). Favor composition over inheritance; keep classes cohesive and immutable where possible.<\/p>\n<pre><code class=\"mono\">interface Shape { double area(); }\r\nclass Circle implements Shape { double r; Circle(double r){this.r=r;} public double area(){return Math.PI*r*r;} }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-cyan\">\n<h3>6) Generics &#038; Type Safety<\/h3>\n<p>Generics provide compile-time type safety and remove casts. Use bounded type parameters (<code>&lt;T extends Number&gt;<\/code>) and wildcards (<code>? super T<\/code>, <code>? extends T<\/code>) to express variance. Prefer generics over raw types to avoid <code>ClassCastException<\/code>.<\/p>\n<pre><code class=\"mono\">List&lt;String&gt; names = List.of(\"A\",\"B\");\r\nfor (String s : names) { \/* ... *\/ }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-lime\">\n<h3>7) Exceptions &#038; Best Practices<\/h3>\n<p>Checked exceptions force callers to handle or declare; unchecked (runtime) don\u2019t. Use checked exceptions for recoverable conditions, unchecked for programming errors. Don\u2019t swallow exceptions; add context and rethrow. Prefer specific exceptions over <code>Exception<\/code>.<\/p>\n<pre><code class=\"mono\">try { Files.readString(Path.of(\"x.txt\")); }\r\ncatch (IOException e) { throw new UncheckedIOException(\"Reading x.txt failed\", e); }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-orange\">\n<h3>8) Immutability<\/h3>\n<p>Immutable objects are thread-safe and simpler to reason about. Make fields <code>private final<\/code>, no setters, and defensive copies of mutable inputs. Use records for concise immutable carriers.<\/p>\n<pre><code class=\"mono\">public record Money(String currency, long cents) { }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-indigo\">\n<h3>9) Records, Sealed Classes, Pattern Matching<\/h3>\n<p><b>Records<\/b> are concise immutable data carriers. <b>Sealed<\/b> classes restrict subclasses. Pattern matching for <code>instanceof<\/code> and <code>switch<\/code> reduces boilerplate.<\/p>\n<pre><code class=\"mono\">sealed interface Shape permits Circle, Rect {}\r\nrecord Circle(double r) implements Shape {}\r\nrecord Rect(double w,double h) implements Shape {}\r\nstatic double area(Shape s) {\r\n  return switch(s) {\r\n    case Circle c -&gt; Math.PI*c.r()*c.r();\r\n    case Rect r   -&gt; r.w()*r.h();\r\n  };\r\n}<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-emerald\">\n<h3>10) Q&#038;A \u2014 \u201cWhy Java for enterprise backends?\u201d<\/h3>\n<p><span class=\"q\">Answer:<\/span> Mature ecosystem (Spring, Jakarta EE), strong performance via JIT &#038; modern GCs, excellent tooling, portability, and long-term compatibility. Java scales from monoliths to microservices with predictable latency and observability support.<\/p>\n<\/p><\/div>\n<p>      <!-- =============== SECTION 2: LANGUAGE & CORE APIs (11\u201320) =============== --><\/p>\n<div class=\"section-title\">Section 2 \u2014 Language &#038; Core APIs<\/div>\n<div class=\"card bg-blue\">\n<h3>11) Strings, Builders, Charset<\/h3>\n<p>Strings are immutable; repeated concatenation builds garbage. Use <code>StringBuilder<\/code> in loops. Always specify charset for I\/O to avoid platform defaults.<\/p>\n<pre><code class=\"mono\">var sb = new StringBuilder();\r\nfor(int i=0;i&lt;1000;i++) sb.append(i);\r\nvar s = sb.toString();<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-green\">\n<h3>12) Collections &#038; Map\/Set<\/h3>\n<p>Choose the right structure: <code>ArrayList<\/code> for indexed access, <code>LinkedList<\/code> for frequent head\/tail ops, <code>HashMap<\/code>\/<code>HashSet<\/code> for average O(1), <code>TreeMap<\/code>\/<code>TreeSet<\/code> for sorted. Prefer interfaces (<code>List<\/code>, <code>Map<\/code>) in APIs.<\/p>\n<pre><code class=\"mono\">Map&lt;String,Integer&gt; freq = new HashMap<>();\r\nfreq.merge(\"java\",1,Integer::sum);<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-amber\">\n<h3>13) Optional<\/h3>\n<p><code>Optional<\/code> models absence\/presence without null. Don\u2019t store in fields; use at boundaries (returns). Use <code>orElse<\/code>\/<code>orElseGet<\/code>\/<code>orElseThrow<\/code>.<\/p>\n<pre><code class=\"mono\">Optional&lt;User&gt; u = repo.find(id);\r\nUser x = u.orElseThrow();<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-violet\">\n<h3>14) java.time API<\/h3>\n<p>Use <code>Instant<\/code>, <code>LocalDate<\/code>, <code>ZonedDateTime<\/code>, and <code>Duration<\/code>. Avoid legacy <code>Date<\/code>\/<code>Calendar<\/code>. Always store in UTC and format with ISO-8601.<\/p>\n<pre><code class=\"mono\">Instant now = Instant.now();\r\nZonedDateTime z = now.atZone(ZoneId.of(\"UTC\"));<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-rose\">\n<h3>15) I\/O &#038; NIO.2<\/h3>\n<p><code>java.nio.file<\/code> offers non-blocking channels and powerful file operations. Use <code>Files<\/code> utility methods for convenience.<\/p>\n<pre><code class=\"mono\">Files.lines(Path.of(\"data.txt\")).forEach(System.out::println);<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-cyan\">\n<h3>16) Streams &#038; Lambdas<\/h3>\n<p>Streams enable declarative data processing; use parallel streams carefully. Avoid side effects inside stream ops; prefer collectors.<\/p>\n<pre><code class=\"mono\">var total = orders.stream().mapToDouble(Order::amount).sum();<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-lime\">\n<h3>17) Functional Interfaces<\/h3>\n<p>Use <code>Predicate<\/code>, <code>Function<\/code>, <code>Supplier<\/code>, <code>Consumer<\/code>, and method references to simplify code. Custom <code>@FunctionalInterface<\/code> can be handy for domain callbacks.<\/p>\n<pre><code class=\"mono\">orders.removeIf(o -&gt; o.isCancelled());<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-orange\">\n<h3>18) Reflection &#038; Annotations<\/h3>\n<p>Reflection lets you inspect types at runtime; annotations add metadata. Use sparingly (frameworks rely on it). Be mindful of performance and module access with JPMS.<\/p>\n<pre><code class=\"mono\">var clazz = Class.forName(\"com.app.User\");\r\nArrays.stream(clazz.getDeclaredMethods()).forEach(System.out::println);<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-indigo\">\n<h3>19) Modules (JPMS)<\/h3>\n<p>The Java Platform Module System (since 9) offers strong encapsulation and reliable configuration. Useful for large codebases and smaller runtime images via <code>jlink<\/code>.<\/p>\n<pre><code class=\"mono\">\/\/ module-info.java\r\nmodule com.app.core { exports com.app.api; }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-emerald\">\n<h3>20) Q&#038;A \u2014 \u201cWhen to use Optional vs null?\u201d<\/h3>\n<p><span class=\"q\">Answer:<\/span> Use <code>Optional<\/code> for return types at boundaries to signal absence. Don\u2019t use in fields\/params. For hot paths, null checks may be faster; for APIs, <code>Optional<\/code> is clearer.<\/p>\n<\/p><\/div>\n<p>      <!-- =============== SECTION 3: CONCURRENCY & VIRTUAL THREADS (21\u201330) =============== --><\/p>\n<div class=\"section-title\">Section 3 \u2014 Concurrency &#038; Virtual Threads<\/div>\n<div class=\"card bg-blue\">\n<h3>21) Threading Basics<\/h3>\n<p>Each Java thread has a stack and executes bytecode on the JVM. Creating too many platform threads is expensive. Use executors to manage pools and avoid manual thread lifecycle.<\/p>\n<pre><code class=\"mono\">ExecutorService pool = Executors.newFixedThreadPool(8);\r\npool.submit(() -&gt; doWork());<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-green\">\n<h3>22) Synchronization &#038; Locks<\/h3>\n<p>Use <code>synchronized<\/code> for intrinsic locks; <code>ReentrantLock<\/code> for advanced control (tryLock, fairness). Guard shared mutable state to avoid data races. Favor immutability to reduce locking.<\/p>\n<pre><code class=\"mono\">synchronized(this){ counter++; }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-amber\">\n<h3>23) java.util.concurrent<\/h3>\n<p><code>ConcurrentHashMap<\/code>, <code>BlockingQueue<\/code>, <code>Semaphore<\/code>, <code>CountDownLatch<\/code>, <code>Atomic*<\/code> types help build safe concurrency. Prefer these over manual wait\/notify.<\/p>\n<pre><code class=\"mono\">var q = new ArrayBlockingQueue&lt;String&gt;(100);\r\nq.put(\"task\");<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-violet\">\n<h3>24) Futures &#038; CompletableFuture<\/h3>\n<p><code>CompletableFuture<\/code> composes async workflows with <code>thenApply<\/code>\/<code>thenCompose<\/code>, timeouts, and combinators. Handle exceptions with <code>exceptionally<\/code> or <code>handle<\/code>.<\/p>\n<pre><code class=\"mono\">CompletableFuture&lt;User&gt; u = repo.getAsync(id).orTimeout(1, TimeUnit.SECONDS);<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-rose\">\n<h3>25) Virtual Threads (Project Loom)<\/h3>\n<p>Virtual threads (Java 21) are lightweight threads scheduled by the JVM, enabling massive concurrency with simple blocking code. They map onto carrier threads as needed, reducing the \u201cthread per request\u201d cost. Great for I\/O-bound services.<\/p>\n<pre><code class=\"mono\">try (var exec = Executors.newVirtualThreadPerTaskExecutor()) {\r\n  exec.submit(() -&gt; fetch());\r\n}<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-cyan\">\n<h3>26) Structured Concurrency<\/h3>\n<p>Structured concurrency (incubator\/APIs evolving) scopes concurrent tasks with lifetimes tied to a parent. It improves cancellation, error handling, and observability.<\/p>\n<pre><code class=\"mono\">\/\/ Pseudocode; APIs evolve across releases\r\n\/\/ try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { ... }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-lime\">\n<h3>27) Executors &#038; Pool Sizing<\/h3>\n<p>Right-size pools to workload. I\/O-bound can use larger pools (or virtual threads). CPU-bound ~ <code>numCores<\/code>. Monitor queue length and task latency to tune.<\/p>\n<pre><code class=\"mono\">ExecutorService cpu = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-orange\">\n<h3>28) Deadlocks &#038; Liveness<\/h3>\n<p>Avoid nested locks and circular waits. Prefer time-bounded lock attempts and clear lock ordering. Watch for livelock and starvation.<\/p>\n<pre><code class=\"mono\">if(lock.tryLock(50, TimeUnit.MILLISECONDS)){ try{ \/*...*\/ } finally { lock.unlock(); } }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-indigo\">\n<h3>29) Reactive vs Blocking<\/h3>\n<p>Reactive stacks (Project Reactor, RxJava) excel under massive I\/O with non-blocking backpressure. Virtual threads let you keep imperative style while scaling. Choose reactive when you need fine-grained non-blocking and streaming; otherwise virtual threads simplify code.<\/p>\n<pre><code class=\"mono\">\/\/ Reactor example\r\nMono&lt;User&gt; u = userClient.get(id);<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-emerald\">\n<h3>30) Q&#038;A \u2014 \u201cVirtual threads vs reactive?\u201d<\/h3>\n<p><span class=\"q\">Answer:<\/span> Virtual threads scale blocking code with minimal refactor; great for request\/response and DB I\/O. Reactive shines for streaming, backpressure, and where non-blocking end-to-end is required. Many teams start with virtual threads; adopt reactive for specialized workloads.<\/p>\n<\/p><\/div>\n<p>      <!-- =============== SECTION 4: BUILD, TEST, SPRING, DATA (31\u201340) =============== --><\/p>\n<div class=\"section-title\">Section 4 \u2014 Build, Testing, Spring, Data<\/div>\n<div class=\"card bg-blue\">\n<h3>31) Maven Basics<\/h3>\n<p>Maven uses declarative <code>pom.xml<\/code> with a standard lifecycle (<code>compile<\/code>, <code>test<\/code>, <code>package<\/code>). Use dependency management, profiles, and plugins (surefire, failsafe, shade). Keep versions centralized; enforce reproducible builds.<\/p>\n<pre><code class=\"mono\">mvn -q -DskipTests package<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-green\">\n<h3>32) Gradle Basics<\/h3>\n<p>Gradle offers flexible Groovy\/Kotlin DSLs, incremental builds, and great performance. Use versions catalogs and the Java toolchain for consistent JDKs across dev\/CI.<\/p>\n<pre><code class=\"mono\">.\/gradlew test\r\n.\/gradlew bootRun<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-amber\">\n<h3>33) JUnit 5 &#038; Mockito<\/h3>\n<p>JUnit 5 (Jupiter) for modular tests, Mockito for doubles, AssertJ for fluent assertions. Parameterized tests improve coverage with less code.<\/p>\n<pre><code class=\"mono\">@Test void adds(){ assertEquals(4, 2+2); }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-violet\">\n<h3>34) Spring Boot Essentials<\/h3>\n<p>Auto-configuration, starters, actuator, profiles. Convention-over-configuration speeds delivery. With Boot 3 (Jakarta EE 10), prefer Java 17+ and leverage native images (GraalVM) if startup\/footprint matters.<\/p>\n<pre><code class=\"mono\">@SpringBootApplication\r\nclass App { public static void main(String[] a){ SpringApplication.run(App.class,a); } }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-rose\">\n<h3>35) Spring MVC &#038; REST<\/h3>\n<p>Annotate controllers, validate inputs, and return DTOs. Use <code>@ControllerAdvice<\/code> for global error handling. Document with OpenAPI\/Swagger.<\/p>\n<pre><code class=\"mono\">@RestController\r\nclass UserApi {\r\n  @GetMapping(\"\/users\/{id}\") User get(@PathVariable String id){ \/*...*\/ return u; }\r\n}<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-cyan\">\n<h3>36) Spring WebFlux (Reactive)<\/h3>\n<p>Non-blocking reactive web stack using Project Reactor. Use for streaming and high-concurrency I\/O. Requires reactive drivers end-to-end to reap benefits.<\/p>\n<pre><code class=\"mono\">@GetMapping(\"\/stream\") Flux&lt;Event&gt; stream(){ return service.tail(); }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-lime\">\n<h3>37) Spring Data JPA &#038; Hibernate<\/h3>\n<p>Repositories remove boilerplate; JPA entities map to tables. Understand fetch types (LAZY\/EAGER), cascades, and transactions. Avoid N+1 queries; use joins and projections.<\/p>\n<pre><code class=\"mono\">@Entity class User { @Id String id; String email; }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-orange\">\n<h3>38) Transactions<\/h3>\n<p>Use <code>@Transactional<\/code> at service layer. Choose isolation and propagation wisely. Keep transactions short; avoid remote calls inside them.<\/p>\n<pre><code class=\"mono\">@Transactional\r\npublic void purchase(){ \/* load, update, save *\/ }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-indigo\">\n<h3>39) Validation &#038; DTOs<\/h3>\n<p>Bean Validation (<code>jakarta.validation<\/code>) with annotations and custom constraints. Validate at edges; map entities to DTOs to protect domain and limit exposure.<\/p>\n<pre><code class=\"mono\">record CreateUser(@NotBlank String email) { }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-emerald\">\n<h3>40) Q&#038;A \u2014 \u201cBoot MVC vs WebFlux?\u201d<\/h3>\n<p><span class=\"q\">Answer:<\/span> MVC is blocking and simple; great for most apps. WebFlux is reactive\/non-blocking; choose it for streaming or extreme concurrency where reactive drivers exist. With virtual threads, MVC scales further while keeping imperative style.<\/p>\n<\/p><\/div>\n<p>      <!-- =============== SECTION 5: DEPLOY, SEC, PERF, OBS, Q&A (41\u201350) =============== --><\/p>\n<div class=\"section-title\">Section 5 \u2014 Deployment, Security, Performance, Observability &#038; Interview Q&#038;A<\/div>\n<div class=\"card bg-blue\">\n<h3>41) Packaging &#038; Runtimes<\/h3>\n<p>Package as JAR (fat\/uber) or build native images with GraalVM for fast startup and low RSS (mind reflection configs). With JPMS and <code>jlink<\/code>, ship trimmed runtimes.<\/p>\n<pre><code class=\"mono\">jlink --add-modules java.base,java.sql --output runtime<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-green\">\n<h3>42) Dockerizing Java<\/h3>\n<p>Use slim base images, layered jars, and reasonable heap settings for containers. Prefer distroless or Alpine carefully (glibc vs musl differences). Expose health endpoints.<\/p>\n<pre><code class=\"mono\">FROM eclipse-temurin:21-jre\r\nCOPY build\/libs\/app.jar \/app.jar\r\nENTRYPOINT [\"java\",\"-jar\",\"\/app.jar\"]<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-amber\">\n<h3>43) JVM Tuning &#038; GC<\/h3>\n<p>Pick GC for workload: G1 (balanced), ZGC\/Shenandoah (low-latency). Size heap for live set + headroom. Measure GC pauses; tune with <code>-Xms<\/code>\/<code>-Xmx<\/code>\/<code>-XX:MaxGCPauseMillis<\/code>.<\/p>\n<pre><code class=\"mono\">java -XX:+UseG1GC -XX:MaxGCPauseMillis=100 -Xms512m -Xmx512m -jar app.jar<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-violet\">\n<h3>44) Performance Tactics<\/h3>\n<p>Avoid premature optimization. Profile with JFR, async-profiler, or JMC. Fix allocations, boxing, and hot loops; cache expensive computations; batch DB calls; use connection pools wisely.<\/p>\n<pre><code class=\"mono\">java -XX:StartFlightRecording=name=app,settings=profile,dumponexit=true -jar app.jar<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-rose\">\n<h3>45) Security Basics<\/h3>\n<p>Validate inputs, escape outputs, use parameterized queries, and store secrets outside code. Enable HTTPS, HSTS, and strong ciphers. Keep dependencies patched (OWASP dependency-check). Sign artifacts when required.<\/p>\n<pre><code class=\"mono\">\/\/ Spring Security starter + method security recommended<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-cyan\">\n<h3>46) Spring Security &#038; JWT<\/h3>\n<p>Use the modern config (SecurityFilterChain). For APIs, JWT with short TTL and refresh rotation. Enforce RBAC\/ABAC, CSRF where applicable, and method-level security.<\/p>\n<pre><code class=\"mono\">@Bean SecurityFilterChain http(HttpSecurity h) throws Exception {\r\n  return h.csrf(csrf -&gt; csrf.disable()).authorizeHttpRequests(a -&gt; a.anyRequest().authenticated()).build();\r\n}<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-lime\">\n<h3>47) Observability<\/h3>\n<p>Use Micrometer for metrics, OpenTelemetry for tracing, and structured logs with context (trace\/span IDs). Expose health\/readiness via Spring Actuator and set SLOs (p95\/p99).<\/p>\n<pre><code class=\"mono\">management.endpoints.web.exposure.include=health,info,prometheus<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-orange\">\n<h3>48) Cloud &#038; Config<\/h3>\n<p>Externalize config (environment, Config Server, Secrets Manager). Use profiles per environment and immutable deployments. Treat logs\/metrics as first-class artifacts.<\/p>\n<pre><code class=\"mono\">spring.profiles.active=prod<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-indigo\">\n<h3>49) Common Pitfalls<\/h3>\n<p>Ignoring N+1 in JPA, mis-sized connection\/thread pools, blocking calls in reactive flows, mutable shared state without locks, poor equals\/hashCode on entities, and swallowing exceptions. Guard with tests, reviews, and observability.<\/p>\n<pre><code class=\"mono\">@Override public boolean equals(Object o){ \/* include business key fields *\/ }<\/code><\/pre>\n<\/p><\/div>\n<div class=\"card bg-emerald qa\">\n<h3>50) Interview Q&amp;A \u2014 20 Practical Questions (Expanded)<\/h3>\n<p><b>1) JDK vs JRE vs JVM?<\/b> JVM runs bytecode; JRE = JVM + libs to run apps; JDK adds compiler and tools for building. Deploy with JRE or jlink image.<\/p>\n<p><b>2) Why LTS?<\/b> Long support window and stable ecosystem; best for prod. Track non-LTS in CI to prepare upgrades.<\/p>\n<p><b>3) How GC works?<\/b> Traces reachable objects; reclaims unreachable. G1 splits heap into regions; ZGC\/Shenandoah aim for low pauses.<\/p>\n<p><b>4) String immutability benefits?<\/b> Thread-safety, caching, interning, secure use as map keys. Use builders to avoid excessive allocations.<\/p>\n<p><b>5) Checked vs unchecked exceptions?<\/b> Checked for recoverable, unchecked for programming errors. Don\u2019t overuse checked; propagate context.<\/p>\n<p><b>6) equals &#038; hashCode?<\/b> Consistent contract; equal objects must have equal hashes. Critical for HashMap\/HashSet behavior.<\/p>\n<p><b>7) Generics erasure?<\/b> Types erased at runtime; use bounded wildcards for flexibility. Avoid raw types.<\/p>\n<p><b>8) Streams vs loops?<\/b> Streams are declarative and composable; loops can be clearer for simple cases. Avoid side effects in stream ops.<\/p>\n<p><b>9) Thread safety strategies?<\/b> Immutability, confinement, synchronization, lock-free atomics, and safe publication.<\/p>\n<p><b>10) Virtual threads?<\/b> Lightweight threads enabling massive concurrency with blocking style; great for I\/O-bound services.<\/p>\n<p><b>11) CompletableFuture vs Future?<\/b> CF composes async pipelines with callbacks, timeouts, and combinators; Future is basic.<\/p>\n<p><b>12) Reactor vs imperative?<\/b> Reactor enables non-blocking backpressure; imperative (with virtual threads) is simpler for request\/response.<\/p>\n<p><b>13) Spring Boot autoconfig?<\/b> Conditional beans based on classpath\/properties; can be customized or excluded via properties and @Conditional.<\/p>\n<p><b>14) Avoiding JPA N+1?<\/b> Fetch joins, entity graphs, projections, and proper batch fetching; inspect SQL logs.<\/p>\n<p><b>15) Transactions best practices?<\/b> Keep short, set proper isolation, avoid remote calls inside, and handle retries idempotently.<\/p>\n<p><b>16) Testing pyramid?<\/b> Unit &gt; integration &gt; selective e2e; use Testcontainers for real deps and wire-mock for externals.<\/p>\n<p><b>17) JVM tuning approach?<\/b> Measure with JFR, identify GC\/alloc hotspots, tune heap\/GC, and verify improvements with load tests.<\/p>\n<p><b>18) Security essentials?<\/b> Input validation, parameterized SQL, strong authn\/z, secrets management, HTTPS, and dependency scanning.<\/p>\n<p><b>19) Packaging choices?<\/b> Fat jar for simplicity; native image for fast startup; jlink for trimmed runtime. Trade off build effort vs ops needs.<\/p>\n<p><b>20) Microservices or monolith?<\/b> Start modular monolith for speed\/clarity; split when scaling\/org needs demand. Invest early in observability.<\/p>\n<\/p><\/div>\n<\/p><\/div>\n<\/p><\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"<p>Java Pocket Book \u2014 Uplatz 50 deep-dive cards \u2022 Wide layout \u2022 Readable code examples \u2022 20+ Interview Q&amp;A Section 1 \u2014 Foundations 1) What is Java? Java is a <span class=\"readmore\"><a href=\"https:\/\/uplatz.com\/blog\/java-pocket-book\/\">Read More &#8230;<\/a><\/span><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2463,2462],"tags":[],"class_list":["post-4403","post","type-post","status-publish","format-standard","hentry","category-java","category-pocket-book"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.3 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Java Pocket Book | Uplatz Blog<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/uplatz.com\/blog\/java-pocket-book\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Java Pocket Book | Uplatz Blog\" \/>\n<meta property=\"og:description\" content=\"Java Pocket Book \u2014 Uplatz 50 deep-dive cards \u2022 Wide layout \u2022 Readable code examples \u2022 20+ Interview Q&amp;A Section 1 \u2014 Foundations 1) What is Java? Java is a Read More ...\" \/>\n<meta property=\"og:url\" content=\"https:\/\/uplatz.com\/blog\/java-pocket-book\/\" \/>\n<meta property=\"og:site_name\" content=\"Uplatz Blog\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/Uplatz-1077816825610769\/\" \/>\n<meta property=\"article:published_time\" content=\"2025-08-09T10:34:16+00:00\" \/>\n<meta name=\"author\" content=\"uplatzblog\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@uplatz_global\" \/>\n<meta name=\"twitter:site\" content=\"@uplatz_global\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"uplatzblog\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/java-pocket-book\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/java-pocket-book\\\/\"},\"author\":{\"name\":\"uplatzblog\",\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/#\\\/schema\\\/person\\\/8ecae69a21d0757bdb2f776e67d2645e\"},\"headline\":\"Java Pocket Book\",\"datePublished\":\"2025-08-09T10:34:16+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/java-pocket-book\\\/\"},\"wordCount\":1778,\"publisher\":{\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/#organization\"},\"articleSection\":[\"Java\",\"Pocket Book\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/java-pocket-book\\\/\",\"url\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/java-pocket-book\\\/\",\"name\":\"Java Pocket Book | Uplatz Blog\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/#website\"},\"datePublished\":\"2025-08-09T10:34:16+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/java-pocket-book\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/uplatz.com\\\/blog\\\/java-pocket-book\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/java-pocket-book\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Java Pocket Book\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/\",\"name\":\"Uplatz Blog\",\"description\":\"Uplatz is a global IT Training &amp; Consulting company\",\"publisher\":{\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/#organization\",\"name\":\"uplatz.com\",\"url\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/wp-content\\\/uploads\\\/2016\\\/11\\\/Uplatz-Logo-Copy-2.png\",\"contentUrl\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/wp-content\\\/uploads\\\/2016\\\/11\\\/Uplatz-Logo-Copy-2.png\",\"width\":1280,\"height\":800,\"caption\":\"uplatz.com\"},\"image\":{\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/Uplatz-1077816825610769\\\/\",\"https:\\\/\\\/x.com\\\/uplatz_global\",\"https:\\\/\\\/www.instagram.com\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/7956715?trk=tyah&amp;amp;amp;amp;trkInfo=clickedVertical:company,clickedEntityId:7956715,idx:1-1-1,tarId:1464353969447,tas:uplatz\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/uplatz.com\\\/blog\\\/#\\\/schema\\\/person\\\/8ecae69a21d0757bdb2f776e67d2645e\",\"name\":\"uplatzblog\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/7f814c72279199f59ded4418a8653ad15f5f8904ac75e025a4e2abe24d58fa5d?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/7f814c72279199f59ded4418a8653ad15f5f8904ac75e025a4e2abe24d58fa5d?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/7f814c72279199f59ded4418a8653ad15f5f8904ac75e025a4e2abe24d58fa5d?s=96&d=mm&r=g\",\"caption\":\"uplatzblog\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Java Pocket Book | Uplatz Blog","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/uplatz.com\/blog\/java-pocket-book\/","og_locale":"en_US","og_type":"article","og_title":"Java Pocket Book | Uplatz Blog","og_description":"Java Pocket Book \u2014 Uplatz 50 deep-dive cards \u2022 Wide layout \u2022 Readable code examples \u2022 20+ Interview Q&amp;A Section 1 \u2014 Foundations 1) What is Java? Java is a Read More ...","og_url":"https:\/\/uplatz.com\/blog\/java-pocket-book\/","og_site_name":"Uplatz Blog","article_publisher":"https:\/\/www.facebook.com\/Uplatz-1077816825610769\/","article_published_time":"2025-08-09T10:34:16+00:00","author":"uplatzblog","twitter_card":"summary_large_image","twitter_creator":"@uplatz_global","twitter_site":"@uplatz_global","twitter_misc":{"Written by":"uplatzblog"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/uplatz.com\/blog\/java-pocket-book\/#article","isPartOf":{"@id":"https:\/\/uplatz.com\/blog\/java-pocket-book\/"},"author":{"name":"uplatzblog","@id":"https:\/\/uplatz.com\/blog\/#\/schema\/person\/8ecae69a21d0757bdb2f776e67d2645e"},"headline":"Java Pocket Book","datePublished":"2025-08-09T10:34:16+00:00","mainEntityOfPage":{"@id":"https:\/\/uplatz.com\/blog\/java-pocket-book\/"},"wordCount":1778,"publisher":{"@id":"https:\/\/uplatz.com\/blog\/#organization"},"articleSection":["Java","Pocket Book"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/uplatz.com\/blog\/java-pocket-book\/","url":"https:\/\/uplatz.com\/blog\/java-pocket-book\/","name":"Java Pocket Book | Uplatz Blog","isPartOf":{"@id":"https:\/\/uplatz.com\/blog\/#website"},"datePublished":"2025-08-09T10:34:16+00:00","breadcrumb":{"@id":"https:\/\/uplatz.com\/blog\/java-pocket-book\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/uplatz.com\/blog\/java-pocket-book\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/uplatz.com\/blog\/java-pocket-book\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/uplatz.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Java Pocket Book"}]},{"@type":"WebSite","@id":"https:\/\/uplatz.com\/blog\/#website","url":"https:\/\/uplatz.com\/blog\/","name":"Uplatz Blog","description":"Uplatz is a global IT Training &amp; Consulting company","publisher":{"@id":"https:\/\/uplatz.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/uplatz.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/uplatz.com\/blog\/#organization","name":"uplatz.com","url":"https:\/\/uplatz.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/uplatz.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/uplatz.com\/blog\/wp-content\/uploads\/2016\/11\/Uplatz-Logo-Copy-2.png","contentUrl":"https:\/\/uplatz.com\/blog\/wp-content\/uploads\/2016\/11\/Uplatz-Logo-Copy-2.png","width":1280,"height":800,"caption":"uplatz.com"},"image":{"@id":"https:\/\/uplatz.com\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/Uplatz-1077816825610769\/","https:\/\/x.com\/uplatz_global","https:\/\/www.instagram.com\/","https:\/\/www.linkedin.com\/company\/7956715?trk=tyah&amp;amp;amp;amp;trkInfo=clickedVertical:company,clickedEntityId:7956715,idx:1-1-1,tarId:1464353969447,tas:uplatz"]},{"@type":"Person","@id":"https:\/\/uplatz.com\/blog\/#\/schema\/person\/8ecae69a21d0757bdb2f776e67d2645e","name":"uplatzblog","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/7f814c72279199f59ded4418a8653ad15f5f8904ac75e025a4e2abe24d58fa5d?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/7f814c72279199f59ded4418a8653ad15f5f8904ac75e025a4e2abe24d58fa5d?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/7f814c72279199f59ded4418a8653ad15f5f8904ac75e025a4e2abe24d58fa5d?s=96&d=mm&r=g","caption":"uplatzblog"}}]}},"_links":{"self":[{"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/posts\/4403","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/comments?post=4403"}],"version-history":[{"count":1,"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/posts\/4403\/revisions"}],"predecessor-version":[{"id":4404,"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/posts\/4403\/revisions\/4404"}],"wp:attachment":[{"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/media?parent=4403"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/categories?post=4403"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/uplatz.com\/blog\/wp-json\/wp\/v2\/tags?post=4403"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}