Github Aws Aws Sdk Java The Official Aws Sdk For Java 1 X In

Spring Boot Migration to 3.x: Challenges along the Journey and Lessons Learned Challenges along the journey of migrating to Spring Boot 3.x and how to successfully resolve them. Hello Guys 🫶 Today I will share with you how we successfully migrated to Spring Boot 3.2.X along with Java 17 by taking advantage of the performance and features of Java 17 and Spring Boot 3.2.X versions. The journey was not very smooth, but quite challenging.

I would be happy to share with you the challenges we faced during this migration phase and how we addressed them. Spring Boot 2.x to 3.2.x Migration Guide Please refer to my Spring Boot Migration Guide below for a detailed walkthrough of the process of migrating from Spring Boot 2.x to 3.x. Picking Optimal AWS SDK for Spring Boot 3 Once we decided to do the Spring Boot migration, one of the major concerns was how to upgrade the AWS SDK.

We were using AWS SDK V1, so should we upgrade to the latest release of SDK V1, or should we completely migrate to AWS SDK V2? <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk</artifactId> <version>1.12.600</version> </dependency> After considering all the facts, we decided to go with the AWS SDK V2. Let me explain why: - SDK Version 2.x includes support for non-blocking I/O, improved start-up performance, automatic iteration over paginated responses, and the ability to plug in a different HTTP implementation at run time, which might come in handy in the long run.

If we decide to migrate our application to a reactive architecture, then at that point, only AWS SDK V2 supports reactive. - The AWS Java SDK version V1 supports Java versions from 7 to 16. The Java 17 version introduces strong encapsulation of internal Java elements, which is not backwards compatible with the Java SDK V1. This may cause issues for certain use cases of the SDK.

Since Spring Boot 3 requires at least Java 17 as a minimum, it is recommended to migrate to AWS SDK V2 at this point. Spring Security Depreceations Spring Boot 3 is only compatible with Spring Security 6. If your applications are using OAuth 2.0 Clients and Resource Servers from Spring Security OAuth 2.x you need to migrate them to to Spring Security 6.x. Before Migration — Spring Security OAuth 2.x Dependency <dependency> <groupId>org.springframework.security.oauth.boot</groupId> <artifactId>spring-security-oauth2-autoconfigure</artifactId> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-jwt</artifactId> </dependency> After Migration — Spring Security 6.x.

Dependency <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-oauth2-resource-server</artifactId> </dependency> A comprehensive guide on how to implement OAuth 2.0 Authorization for Spring Boot 3 Applications using Spring Security 6 is available below. Unit Test Issues Mockito issue with Generic Mock Classes Once we upgrade the Spring Boot version to 3.2.0, it automatically picks the mockito version as: <mockito.version>5.7.0</mockito.version> We noticed after the migration that all the unit tests with a Generic Mock in the superclass failed. The problem was that Mockito could not inject a generic mock.

org.opentest4j.AssertionFailedError: Unexpected exception thrown: java.lang.NullPointerException: Cannot invoke "java.util.List.size()" because "this.list" is null at org.junit.jupiter.api.AssertionFailureBuilder.build(AssertionFailureBuilder.java:152) at org.junit.jupiter.api.AssertDoesNotThrow.createAssertionFailedError(AssertDoesNotThrow.java:84) at org.junit.jupiter.api.AssertDoesNotThrow.assertDoesNotThrow(AssertDoesNotThrow.java:75) at org.junit.jupiter.api.AssertDoesNotThrow.assertDoesNotThrow(AssertDoesNotThrow.java:58) at org.junit.jupiter.api.Assertions.assertDoesNotThrow(Assertions.java:3228) at com.cloud.events.cloudeventsspring.ProducerTest.testGetOutput(ProducerTest.java:28) at java.base/java.lang.reflect.Method.invoke(Method.java:580) at java.base/java.util.ArrayList.forEach(ArrayList.java:1596) at java.base/java.util.ArrayList.forEach(ArrayList.java:1596) public abstract class GenericProducer<T> { @Autowired private List<T> list; public Integer getSize(){ return list.size(); } } @Service public class Producer extends GenericProducer<Person> { public Integer getSize() { return getOutput(); } } public class ProducerTest { @Mock private List<Person> list; @InjectMocks private Producer producer; @BeforeEach public void init() { MockitoAnnotations.openMocks(this); } @Test public void testGetOutput() { Assertions.assertDoesNotThrow(()-> producer.getSize()); } } The only solution I could come up with was downgrading Mockito to check if there was a regression.

Surprisingly, I found it works with Mockito 5.1.1 as expected. <mockito.version>5.1.1</mockito.version> Incompatibility with PowerMock With the transition of Junit5, PowerMock is not compatible with Spring Boot 3 and JDK 17. So we had to completely move toMockito . With the transition to Mockito from PowerMock, we had to rewrite static mocks using Mockito’s mockStatic method.

@UtilityClass public class StringUtils { public String trim(final String input) { return input.trim(); } } @BeforeEach public void init() { mockStatic(StringUtils.class); } @Test public void testGetOutput() { when(StringUtils.trim(anyString())).thenReturn("OUTPUT"); var result = StringUtils.trim("INPUT"); Assertions.assertEquals("OUTPUT", result); } Hibernate Issues A change in the default naming strategy for Hibernate 6.0 is causing sequences to not work as expected.

Once we upgrade the Spring Boot version to 3.2.0, it automatically picks the hibernate version as: Once we upgraded to Spring Boot version 3.2.0, it automatically picked Hibernate 6, and Hibernate 6 changed the default naming strategy. Because of that, Hibernate might try using a sequence that doesn’t exist in our database and throw an error. 2024-01-23 16:57:13,715 WARN 1736 --- [http-nio-9637-exec-1] SqlExceptionHelper/133 - SQL Error: 0, SQLState: 42P01 2022-01-23 16:57:13,715 ERROR 1736 --- [http-nio-9637-exec-1] SqlExceptionHelper/138 - ERROR: relation ".

person_seq" does not exist How Hibernate determines implicit names for sequences and tables associated with identifier generation has changed in 6.0. As of 6.0, Hibernate by default creates a sequence per entity hierarchy instead of a single sequencehibernate_sequence . Because of this change, if we previously used: @GeneratedValue(strategy = GenerationStrategy.AUTO) or simply @GeneratedValue (since AUTO is the default), need to ensure that the database now contains sequences for every entity, named <entity name>_seq . For an entity Person , a sequence person_seq is expected to exist.

According to Hibernate, this is the recommended approach. Naming strategies supported by Hibernate 6 Previous Hibernate versions provided one default behaviour, and you had to specify the sequence name if you wanted to use a different one. With Hibernate 6, you can choose between 4 implicit naming strategies for database sequences: standard : This is the new default in Hibernate 6.

It concatenates the configured sequence suffix, which is_SEQ by default, to the name of the table that’s mapped by the entity class.legacy : This naming strategy provides you with the same behaviour as the Hibernate versions >= 5.3 but <6 used by default. Hibernate uses the generator name if you reference a generator without defining a sequence name. If your mapping doesn’t reference a generator, Hibernate uses its default sequence namehibernate_sequence .single : This naming strategy provides you with the same behaviour as Hibernate, used in version <5.3 by default.

It always uses Hibernate’s default sequence namehibernate_sequence .custom Implementation : Giving a fully qualified class name of anImplicitDatabaseObjectNamingStrategy implementation. To help with backwards compatibility, or to apply any general naming strategy, 6.0 introduces the org.hibernate.id.enhanced.ImplicitDatabaseObjectNamingStrategy contract which can be specified using the hibernate.id.db_structure_naming_strategy setting.

Backwards Compatibility Approach Since we were previously using the hibernate version 5.4.30.Final for backwards compatibility, we changed the db_structure_naming_strategy to: spring.jpa.properties.hibernate.id.db_structure_naming_strategy: legacy Customizing the GenerationType AUTO For all entities with GenerationType.AUTO we can change as follows; @Entity public class Person { @Id @GenericGenerator(name = "person_generator", type = IdentityGenerator.class) @GeneratedValue(strategy = GenerationType.AUTO, generator = "person_generator") private Integer id; private String name; } Hibernate Query Semantic Exceptions After the migration to Spring Boot 3, you might notice getting such validation issues when the application starts in the validation phase: Caused by: org.hibernate.query.SemanticException: Cannot compare left expression of type 'java.lang.String' with right expression of type 'java.lang.Integer' Let’s consider the below query: @Entity public class Person { @Id private Integer id; private String tag; } @Query(value = "SELECT * FROM Person p WHERE p.tag IN (10,20)") List<Person> fetchRetiredPeople(@Param("tag") String tag); The cause for the above issue in Hibernate version 6 is that previous versions didn’t care to validate the comparability of expressions and so ended up producing invalid SQL instead.

However, the latest Hibernate version 6.0 validates and throws SemanticException because we are trying to compare p.tag a String which is the left-side expression with (10,20) an Integer Array which is the right-side expression. To resolve this issue, we need to fix the query to pass the newer validations.

@Query(value = "SELECT * FROM Person p WHERE p.tag IN ('10','20')") List<Person> fetchRetiredPeople(@Param("tag") String tag); Missing classes inside the Spring Boot Configuration Processor, like JSONException and JSON You will only encounter this error after you have built your Spring Boot application and deployed it to any environment with the application Jar. This will never reproduce locally. Caused by: java.lang.ClassNotFoundException: org.springframework.boot.configurationprocessor.json.JSONException at java.base/java.net.URLClassLoader.findClass(URLClassLoader.java:445) at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:587) at org.springframework.boot.loader.LaunchedURLClassLoader.loadClass(LaunchedURLClassLoader.java:151) at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520) ... 46 more Let’s Understand the root cause for this issue.

As per the Documentation, Starting with SpringBoot 2.4 the dependency org.springframework.boot:spring-boot-configuration-processor is no longer contained in the resulting fat jar because, When generating runnable Spring Boot jars, empty starter dependencies will automatically removed. Since most starters only provide transitive dependencies, there is little point in packaging them in the final jar. Spring Boot annotation processors are also removed as well as they are only useful during the build. These are spring-boot-autoconfigure-processor and spring-boot-configuration-processor.

How to resolve the Issue Check whether you are using classes from configurationprocessor as such; org.springframework.boot.configurationprocessor.json.JSONException org.springframework.boot.configurationprocessor.json.JSONObject If you are using those, replace them with: org.json.JSONException org.json.JSONObject You might need to include the related dependency: <dependency> <groupId>org.json</groupId> <artifactId>json</artifactId> <version>20231013</version> </dependency> Java Encoding issues after upgrading to Java 17 After we migrated to Java 17 using OpenJDK, we noticed that whenever we used non-ASCII characters, it caused issues in our application.

This was because In JDK 18 and later, UTF-8 is the default charset used by Java SE APIs on all operating systems. See JEP 400: UTF-8 by Default. In JDK 17 and earlier releases, the default charset is determined when the Java runtime starts, that is, on macOS, the default charset used to be UTF-8. On other operating systems, it used to depend on the user’s locale and the default encoding. All our test cases that used the default charset were failing because they were not using UTF-8.

As per the below example, the FileWriter is not using the default charset as UTF-8 causing the failure of the previous test case for this method.

public File generateReport(List<Person> data, final String outputFile) throws IOException { final File parent = Files.createTempDirectory(String.valueOf(System.nanoTime())).toFile(); final File report = new File(parent, outputFile); try (final BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile))) { data.forEach(person -> { try { writer.write(person.getName()); } catch (IOException e) { throw new RuntimeException(e); } }); } return report; } How to resolve the issue Setting the File Encoding Property to UTF-8 Option-1: MAVEN_OPTS=-Dfile.encoding=UTF-8 Option-2: <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>${maven-surefire-plugin.version}</version> <configuration> <argLine>-Dfile.encoding=UTF-8</argLine> </configuration> </plugin> Option-3: Passing the charset to be used explicitly.

public File generateReport(List<Person> data, final String outputFile) throws IOException { final File parent = Files.createTempDirectory(String.valueOf(System.nanoTime())).toFile(); final File report = new File(parent, outputFile); try (final BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile, StandardCharsets.UTF_8))) { data.forEach(person -> { try { writer.write(person.getName()); } catch (IOException e) { throw new RuntimeException(e); } }); } return report; } Spring Cloud Sleuth was removed and moved to MicrometerTracing After migrating to the latest Spring Boot version 3.x, you can no longer use Sleuth for observability. In Spring Boot 3, Sleuth got moved to Micrometer Tracing.

The Brave and OpenTelemetry bridges have their respective modules in Micrometer Tracing that you can use to implement observability. Spring Cloud Sleuth API Migration The whole Spring Cloud Sleuth API module got pretty much moved to Micrometer Tracing. That means that in the vast majority of places, you should just change the package from org.springframework.cloud.sleuth toio.micrometer.tracing . Spring Cloud Sleuth and Micrometer Tracing can’t Work Together Spring Cloud Sleuth and Micrometer Tracing, by default, use different tracing formats and are therefore incompatible with each other.

Spring Cloud Sleuth uses the Zipkin b3 format (eg: x-b3-TraceId ) Micrometer Tracing uses the w3c Trace Context format (eg: traceparent=00-xxxx-xxxx-01 ) Migrating from Sleuth to Micrometer You can refer to my Spring Boot 3 Observability Series to understand how to implement Observability after migrating to Spring Boot 3 all across your application covering: - Metrics Monitoring - Log Monitoring - Monitoring Traces Thank You for Reading - Please feel free to share your feedback. - Stay connected for more Insightful content.

People Also Asked

• GitHub-aws/aws-sdk-java:TheofficialAWSSDKforJava1.x(In...)
• AWSSDKforJava| Amazon Web Services, Inc.
• Maven Repository: software.amazon.awssdk»aws-sdk-java
• Spring Boot Migration to 3.x: Challenges along the Journey and...
• Amazon S3 WithJava| Baeldung
• We Are Formalizing Our Plans To EnterAwsSdkFor... | Vrogue
• GitHub-aws/aws-sdk-java-v2:TheofficialAWSSDKforJava...