Singleton is a widely used Design Pattern which guarantees a single instance of a given class is created within an application process. This is a very good design pattern for creating instances which have a very high cost for creation in terms of memory and cpu.
A typical Singleton class for a UserService will look like following;
Java is nearing its next Long Term Support (LTS) Release which is Java 17. Thus far it has released Java 16 General Availability (GA) Release which can be used in Production. There are some new features available in Java 16 which we are going to look at right now.
Record
Record is simplified way to declare a class which is used only to represent data. This type of classes are defined as Data Transfer Objects (DTO) or Entities in ORM frameworks to represent Tables. The current way to declare this type of classes is to create a public class with properties and all argument constructor and define all getters/setters along with equals, hashCode and toString. This requires a lot of additional code which can be reduced using code generation libraries and plugins like Lombok yet it is still an hassle.
Java 16 introduces record type to ease creation of such classes.
import java.util.*;
public class RecordTest {
public static void main(String... args) {
Student s1 = new Student(1, "Shazin", 1);
Student s2 = new Student(2, "Shahim", 2);
System.out.println("Student 1 : "+s1);
System.out.println("Student 2 : "+s2);
System.out.println("s1 == s2 : "+(s1 == s2));
System.out.println("s1.equals(s1) : "+(s1.equals(s1)));
System.out.println("s1.equals(s2) : "+(s1.equals(s2)));
record GraduateStudent(Student student, List<String> qualifications) {};
GraduateStudent gs1 = new GraduateStudent(s1, Arrays.asList("A/S", "BSc"));
System.out.println("GraduateStudent 1 : " + gs1);
}
private static record Student(Integer id, String name, Integer grade) {
public Student { // All args constructor
if (grade < 0 || grade > 13) {
throw new IllegalArgumentException("Grade must be between 1 and 13");
}
}
}
} List<Integer> evenNos = nos.stream().filter(i -> i % 2 == 0).toList(); //.collect(Collectors.toList())
System.out.println("Even numbers : "+evenNos);
import java.util.*;
public class PatternMatchingTest {
public static void main(String... args) {
String name = "Shazin";
List<Integer> nos = Arrays.asList(1, 2, 3, 4, 5);
Map map = Collections.singletonMap("Key", "Value");
Long bigInt = 1l;
System.out.println("Name Length : " + length(name));
System.out.println("Nos Length : " + length(nos));
System.out.println("Map Length : " + length(map));
System.out.println("bigInt Length : " + length(bigInt));
}
private static int length(Object o) {
if (o instanceof String s) { // s variable of type String
return s.length();
} else if (o instanceof Collection c) { // c variable of type Collection
return c.size();
} else if (o instanceof Map m) { // m variable of type Map
return m.size();
} else { // o variable of type Object
return 0;
}
}
}
Cloud Computing has taken the IT world by storm because of its versatility, low initial capital required to get started and low operational costs. Many new programming languages/platforms such as Go, Node JS, etc. have been tailormade to work on Cloud nodes
But many Enterprise level Software applications still run on Java and have failed to harness full capabilities of the Cloud due to its high memory footprint and high latency due to its Just in Time (JIT) compilation. These contribute to slower start up times and cold starts.
In order to tackle problems Oracle Labs Team introduced a VM called GraalVM which enabled language agnostic method to produce Cloud Native applications using Java (not only Java) along with capabilities to integrate Spring as well.
In order to harness the capabilities of GraalVM and easy development Spring introduced a developer tool named Spring Native which enables to convert most of the Spring Applications to Docker Container Images with GraalVM image as base which converts the Spring Application to a Native application runs it.
This enables faster startup time, low latency and low memory usage. GraalVM achieves this by using its Ahead of Time (AOT) compilation and building capabilities.
You can use this developer tool directly from Spring Initializr as below;
@SpringBootApplication
@RestController
@RequestMapping("/native")
public class SpringNativeDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringNativeDemoApplication.class, args);
}
@PostConstruct
public void init() {
System.out.println("Initialized...");
}
@GetMapping("/greet")
public String greet() {
return "Hello";
}
}
<dependency>
<groupId>org.springframework.experimental</groupId>
<artifactId>spring-native</artifactId>
<version>${spring-native.version}</version>
</dependency>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<image>
<builder>paketobuildpacks/builder:tiny</builder>
<env>
<BP_NATIVE_IMAGE>true</BP_NATIVE_IMAGE>
</env>
</image>
</configuration>
</plugin>
./mvnw spring-boot:build-image
This will generate the native image with ahead of time compilation. The generated executable will have all the necessary classes and statically linked native code from the SDK. Substrate VM which is a docker image provided by GraalVM is used here as the base of the image.
./docker images | grep spring-native-demo
./docker run -p 8088:8080 spring-native-demo:0.0.1-SNAPSHOT
This will start up the Spring Application very quickly due to the Ahead of Time compilation capability of GraalVM.
You can hit the endpoint using following command or by visiting the url in a browser;
curl localhost:8088/native/greet --silent
As of now not all Spring Eco System modules are supported in Spring Native. But it is a work in progress.
Recently I was working on a Project which involved Spring Data Elasticsearch and needed to use geo_point type field in the Elasticsearch index for speedier location based searches. Spring Data Elasticsearch provides a data type by the name GeoPoint to achieve this and an annotation named @GeoPointField to mark such fields.
@Document(indexName = "properties", replicas = 0, refreshInterval = "-1")
public class Property implements Serializable {
...
@GeoPointField
private GeoPoint location;
...
But sadly for me creating a repository out for the above @Document and saving objects was keep on converting the GeoPoint field to a plain map of latitude and longitude but not as a geo_point field.
"location": {
"properties": {
"latitude": {
"type": "string"
},
"longitude": {
"type": "string"
}
}
} This results in following error while querying using Geo Distance Query.
QueryParsingException failed to find geo_point field
After some research I finally found out that in such cases we would need to manually create the index before calling Repository.save.
In a service or any other initializer class you need to do the following;
@Autowired
private ElasticsearchRestTemplate elasticsearchRestTemplate;
@PostConstruct
public void init() {
IndexOperations indexOperations = elasticsearchRestTemplate.indexOps(Property.class);
indexOperations.putMapping(indexOperations.createMapping());
indexOperations.refresh();
}
This fixes the issue and creates the location field with type geo_point as expected.
public interface AuthenticationManager {
Authentication authenticate(Authentication authentication)
throwsAuthenticationException;
}public interface AuthenticationProvider {
Authentication authenticate(Authentication authentication)
throwsAuthenticationException;
boolean supports(Class authentication);
}public interface UserDetailsService {
UserDetailsloadUserByUsername(String username) throws UsernameNotFoundException;
}@Configuration
@EnableWebSecurity
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
public void confGlobalAuthManager(AuthenticationManagerBuilderauth) throws Exception {
auth.inMemoryAuthentication()
.withUser("admin")
.password("admin@password")
.roles("ROLE_ADMIN");
}
}@Configuration
@EnableWebSecurity
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(AuthenticationManagerBuilderauth) throws Exception {
auth.inMemoryAuthentication()
.withUser("admin")
.password("admin@password")
.roles("ROLE_ADMIN");
}
}@Override
publicAuthenticationManagerauthenticationManagerBean() throws Exception {
returnsuper.authenticationManagerBean();
}
@Component
public class CustomAuthenticationProvider implements AuthenticationProvider {
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException
{
String username = authentication.getName();
String password = authentication.getCredentials().toString();
if ("user".equals(username) && "password".equals(password)) {
return new UsernamePasswordAuthenticationToken(username, password, Collections.emptyList());
} else {
throw new BadCredentialsException("Authentication failed");
}
}
@Override
publicboolean supports(ClassaClass) {
returna Class.equals(UsernamePasswordAuthenticationToken.class);
}
}@EnableWebSecurity
@ComponentScan(basePackageClasses = CustomAuthenticationProvider.class)
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
CustomAuthenticationProvider customAuthenticationProvider;
@Override
protected void configure(HttpSecurity http) throws Exception {
http.httpBasic()
.and()
.authorizeRequests()
.antMatchers("/**")
.authenticated(); // Use Basic authentication
}
@Override
protected void configure(AuthenticationManagerBuilderauth) throws Exception {
// Custom authentication provider - Order 1
auth.authenticationProvider(customAuthenticationProvider);
// Built-in authentication provider - Order 2
auth.inMemoryAuthentication()
.withUser("admin")
.password("{noop}admin@password")
//{noop} makes sure that the password encoder doesn't do anything
.roles("ADMIN") // Role of the user
.and()
.withUser("user")
.password("{noop}user@password")
.credentialsExpired(true)
.accountExpired(true)
.accountLocked(true)
.roles("USER");
}
}
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-actuator</artifactid>
<version>Version</version>
</dependency>
@Configuration
@Import({
EndpointWebMvcAutoConfiguration.class,
ManagementServerPropertiesAutoConfiguration.class,
EndpointAutoConfiguration.class
}) <build>
<pluginmanagement>
<plugins>
<plugin>
<groupid>pl.project13.maven</groupid>
<artifactid>git-commit-id-plugin</artifactid>
<version>2.2.4</version>
<executions>
<execution>
<id>get-the-git-infos</id>
<goals>
<goal>revision</goal>
</goals>
<phase>package</phase>
</execution>
<execution>
<id>validate-the-git-infos</id>
<goals>
<goal>validateRevision</goal>
</goals>
</execution>
</executions>
<configuration>
<dotgitdirectory>${project.basedir}/../.git</dotgitdirectory>
<dateformat>yyyy-MM-dd'T'HH:mm:ssZ</dateformat>
<dateformattimezone>${user.timezone}</dateformattimezone>
<generategitpropertiesfile>true</generategitpropertiesfile>
<generategitpropertiesfilename>${project.build.outputDirectory}/git.properties</generategitpropertiesfilename>
<format>properties</format>
<skippoms>true</skippoms>
<injectallreactorprojects>false</injectallreactorprojects>
<failonnogitdirectory>true</failonnogitdirectory>
<failonunabletoextractrepoinfo>true</failonunabletoextractrepoinfo>
<commitidgenerationmode>flat</commitidgenerationmode>
<gitdescribe>
<skip>false</skip>
<always>true</always>
<dirty>-dirty</dirty>
<match>*</match>
<tags>false</tags>
<forcelongformat>false</forcelongformat>
</gitdescribe>
<validationproperties>
<validationproperty>
<name>validating project version</name>
<value>${project.version}</value>
<shouldmatchto><![CDATA[^.*(?<!-SNAPSHOT)$]]></shouldmatchto>
</validationproperty>
</validationproperties>
</configuration>
</plugin>
</plugins>
</pluginmanagement>
</build>
$ mvn clean package git-commit-id:revision 
DefNew + CMS : -XX:-UseParNewGC -XX:+UseConcMarkSweepGC
ParNew + SerialOld : -XX:+UseParNewGC
ParNew + iCMS : -Xincgc
ParNew + iCMS : -XX:+CMSIncrementalMode -XX:+UseConcMarkSweepGC
DefNew + iCMS : -XX:+CMSIncrementalMode -XX:+UseConcMarkSweepGC -XX:-UseParNewGC
CMS foreground : -XX:+UseCMSCompactAtFullCollection
CMS foreground : -XX:+CMSFullGCsBeforeCompaction
CMS foreground : -XX:+UseCMSCollectionPassing-XX:+PrintGC will be changed to -Xlog:gc
-XX:+PrintGCDetails will be changed to -Xlog:gc*
-xloggc: will be changed to -Xlog:gc:
