DEV Community: Thinking out code

Speed up your search app with Redis

Thinking out code — Thu, 18 Aug 2022 14:16:49 +0000

Searching apps, browsers, results found, etc; a huge percentage of apps have something related to finding detailed info in the database, in some cases with many requests per minute. This feature came from finding a word to entire rows of information.

Let’s pretend that we have a hypothetical user, called Bob, he has the requirement for a Star Wars application that allows him, to find info about his favorites character from star wars movies, searching by a complete word, Bob needs an application that has an effective time of response and consumes from different sources of data.

We’re talking about a considerable amount of content, including people, planets, starships, and any interesting topic about that movie. Let’s say we are the team behind that development. First of all, let’s clarify the original premise with the flow:

Basic flow app

As shown in the diagram below, there is one case with 3 possible scenarios:

Bob searches for a word, the word is found on the API source, and the result list is returned
Bob searches for a word, the word isn’t found on the API source but is found on the database source, and the result list is returned.
Bob searches for a word, but the word isn’t found nor database source or API source, no content response is returned.

Bob has his desired application, at least in theory, with a global search around all possible content from his favorite movie with two different data sources.
Let’s bring some code to live, to test this design, I’ll show step by step every component.

Hands-on code

@RestController("/finder")
public class SearchRestController {

    @Autowired
    private SearchService searchService;

    @GetMapping("/")
    public ResponseEntity<List<ItemDTO>> searching(@RequestParam String word) {
        Long start = System.currentTimeMillis();
        Optional<List<ItemDTO>> results = searchService.getListBy(word);
        System.out.println("Searching for " + (System.currentTimeMillis() - start) + " ms");
        return ResponseEntity.of(results);
    }
}

This is a simple controller with one method declared, searching, with GetMapping request, that receives a word through params from request, calls to the SearchService method, and responds with the list of results founds.

@Component
public class SearchService {

    @Autowired
    private ApiClient apiClient;
    @Autowired private StarWarsRepository starWarsRepository;
    @Autowired private ObjectMapper mapper;

    public Optional<List<ItemDTO>> getListBy(String word) {
        return apiClient.findBy(word)
                .or(() -> findAllByName(word));
    }

    private Optional<List<ItemDTO>> findAllByName(String word) {
        List<Item> items = starWarsRepository.findAllByName(word);
        if (items.isEmpty()) return Optional.empty();
        List<ItemDTO> itemDTOS = new ArrayList<>();
        items.forEach(item -> itemDTOS.add(mapper.convertValue(item, ItemDTO.class)));
        return Optional.ofNullable(itemDTOS);
    }
}

It receives a word from the controller and:

Call the API client.

@Component
public class ApiClient {

    @Autowired
    private RestTemplate restTemplate;
    static final String API_URL = "https://swapi.dev/api/people";

    public Optional<List<ItemDTO>> findBy(String word) {
        ResponseEntity<ResultsDTO> responseEntity = restTemplate
                .getForEntity(API_URL.concat("?search=").concat(word), ResultsDTO.class);
        if (Objects.requireNonNull(responseEntity.getBody()).getResults().isEmpty())
            return Optional.empty();
        return Optional.of(Objects.requireNonNull(responseEntity.getBody()).getResults());
    }
}

It executes a request to the StarWars Api with the search.

If no result has returned, it executes a call to the database repository.

@Repository
public interface StarWarsRepository extends CrudRepository<Item, Long> {

    List<Item> findAllByName(String word);
}

It searches for similar terms in the table called star_word. In this case, it will be using a simple h2 database due to the concept test, you could implement it with another type of SQL driver. To fill this database you have to execute the next script. You could adapt it as you need it.

insert into item(name, height) values('name1', '121');
insert into item(name, height) values('name2', '121');
insert into item(name, height) values('name3', '121');
insert into item(name, height) values('name4', '121');
insert into item(name, height) values('name5', '121');

The structure of the principal object would be:

public class Item {
    private Long id;
    private String name;
    private String height;
}

Nothing crazy, just basic fields. Helped by Lombok annotations.

Our pom file has declared the next dependencies:

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
       </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.9.0</version>
        </dependency>

Jedis: a Java client for Redis.
Spring-boot-starter-data-redis: Provides easy configuration and access to Redis from Spring Apps, offering low-level and high-level abstractions for interactions with the database without architecture worries.
h2 In-memory database.
Lombok: Oriented to decorator pattern to avoid boilerplate code.
Spring-boot-starter-data-jpa: Implements a data access layer.

Having those configurations and custom classes, now the application had covered the case of the basic design. Let’s see how would be the performance in terms of time(ms) of the search process, having it “up and running”, in the next 2 possible scenarios:

API

curl http://localhost:8080/?word=luke

{
    "name": "Luke Skywalker",
    "height": "172"
}

Searching for 1237 ms

Database

curl http://localhost:8080/?word=name1

{
    "name": "name1",
    "height": "121"
}

Searching for 1289 ms

After executing those cases, take a look at the next table:

Case	API Datasource(ms)	Database source(ms)
Results found(time response)	1237	1289

As is shown, the database source takes a little more time than the API source. The response time is not a big thing right now but what could happen when the database makes it bigger? or there are not only two sources of data(API, database), but a lot more? Our app could make better searches?

The answer is yes, but it needs to take into count what corner cases it has right now. In the next implementation, we’ll see one of them.

The problem of search the same thing over and over again

What about the case of one o more Bob users, searching by the same word, with many requests but the same word to search? Is it worth the effort of making a searching process for every similar term?

Taking this scenario as an example, let's think about how could improve the performance, in that case, to avoid ping to several API or data sources when a term has previous searching tries, and ping to a source in common that stores this similar searches with a lesser time response, something like that:

Search design with a third source feature.

The third data source act like cache storage, understanding as cache as a temporary store.

A possible new improvement…

Same one case than the beginning but adding 2 additional steps:

Bob searches for a word, and the word was found on an API source, the result is stored in a third source, and it is returned.
Bob searches for a word, the word wasn’t found on the API source but is found on the database source, the result is stored in a third source, and it is returned.
Bob searches for a word, the word was found on a third source, and the result list was returned.
Bob searches for a word, but the word wasn’t found nor database source nor API source, or third source, no content response is returned.

There are no additional steps when data was searched before because it was stored in the first request, being available for after requests, avoiding repetitive searches, and improving the app performance.

It looks simple, but what would be the characteristics that must have this third data source?

Low latency.
Capable of saving and returning data quickly.
Searching by word.
Native integration with our tech stack.

An option that probably fits with these specs, would be Spring cache, which offers different options for dealing with this type of design, allowing storing and getting data for recent results with useful configuration related and a minimal time of response.

Making it real with Spring and Redis cache integration

Spring cache is a configuration that uses proxies pattern properties to interrupt request data flow, adding a third component with Redis, acting as cache storage, due to the nature of Redis, easy integration, and fast response time.

Redis also :

Can perform more than 11000 sets per second and more than 8000 gets per second.
Due to the principle of no schemas, in this kind of database(key-value), it doesn’t need a strong definition of the objects to store, could be starting from a simple string value to a POJO.
Has a property to expire values stored, making it temporarily store data.
Easy indexes configuration.

Updating our previous design, we have the following:

Redis, representing our cache storage

Now, we have the whole picture, with Redis in it as our third data source.

Let’s update our code

Adding EnableCaching annotation to the main class

@SpringBootApplication
@EnableCaching
public class GrapefruitApplication {

    public static void main(String[] args) {
        SpringApplication.run(GrapefruitApplication.class, args);
    }
}

This annotation is responsible of register related components to cache management like the CacheInterceptor and other proxies that allows @Cacheable works. Spring has the next annotations available:

@CacheEvict evict a mapping based in a key.
@CachePut causes the method to be invoked and its result to be stored in the associated cache related to the condition() and unless() expressions.
@Caching grouping cache annotations.
@Cacheable indicate that the result of invoking a method or all method in a class can be cached.

How works `@Cacheable` in terms of Redis?

It executes a get-by key to the Redis database, if it doesn’t return a result, it executes a put command to store the newly found result after executing the method invocation. Redis allows the storing of null results by key but this property could be set by the previous configuration.

Let’s see how to look at the service method after updating it.

    @Cacheable(value = "itemCache",
            key = "{#word}", unless="#result == null")
    public Optional<List<ItemDTO>> getListBy(String word) {
        return apiClient.findBy(word)
                .or(() -> findAllByName(word));
    }

As I said before, there is a key that represents the index of objects stored in Redis, the value property represents the name of cache storage in Redis, and the unless the property is for preventing null values.
In the same idea, there are RedisCacheManagerBuilderCustomizer and RedisCacheConfiguration beans, which allow set expiring time for cache values, serialization strategy, etc.

        @Bean
    public RedisCacheConfiguration cacheConfiguration() {
        return RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(60))
                .disableCachingNullValues()
                .serializeValuesWith(
                        RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
    }

    @Bean
    public RedisCacheManagerBuilderCustomizer redisCacheManagerBuilderCustomizer() {
        return (builder) -> builder
                .withCacheConfiguration("itemCache", cacheConfiguration());
    }

Setting up this with the Redis configuration file(application.yaml).

spring:
  datasource:
    url: jdbc:h2:mem:starwars
    driverClassName: org.h2.Driver
  jpa:
    defer-datasource-initialization: true
  redis:
    host: yourHost
    port: yourPort
    username: yourUsername
    password: yourPassword

You could use a local environment for Redis or the Redis Lab environment with the free plan that allows 30MB of storage with high availability and also is easy to set up. In this link, there are some references on how to connect with the Redis cloud environment that you could find useful.

Having our application updated, with all the configurations before, it only takes some test to see how works this new adding feature:

Let’s try with a luke word search:

curl http://localhost:8080/?word=luke

{
    "name": "Luke Skywalker",
    "height": "172"
}

Searching for 1237 ms

Let’s try again with the same searching:

curl http://localhost:8080/?word=luke

{
    "name": "Luke Skywalker",
    "height": "172"
}

Searching for 175 ms

175 ms! More than 70% of improvement.

Happy Lisa Simpson GIF - Find & Share on GIPHY

Discover & share this Animated GIF with everyone you know. GIPHY is how you search, share, discover, and create GIFs.

giphy.com

Look what we have here! the response time is lower than its preview results by more than 70 percent, and of course, the last request was executed in a previews step, so the request is redirected through our cache interceptor, which stored the previous data list result.

Updating the previous comparator table, there is the following:

Case	API Datasource(ms)	Database source(ms)	Redis source (ms)
Results found	1237	1289	175

If we make a comparison in terms of big o notation efficiency, for a case with previously requested searches, we have an O(1) result, making an improvement in terms of time and steps because there are no additional steps when a search has been requested before.

Think about how this could improve content search, dictionary apps, browsers, and wikis explorer.

Oh yeah! This looks really good but what about the cons?

Well, yes, there is a disadvantage that I would like to mention; this feature cannot be applied in the case where our data sources are constantly changing, because the cache store doesn’t have the last version of them, only the last snapshot when were requested by the user. If we talking about banking accounts and their related balance, this could be a problem. Another case that could be a problem is when you are checking a tracking application about delivery service, this cannot show the recent state of your shopping.

Or when you are searching for items in a catalog of an e-commerce site, you need that item stocks to be updated for not to buy stuff without inventory. An improvement that could fit with this type of app, is recent searches, suggesting to the user based on its first letters written where the key of cache object would bet those starting letters and the object related to the items list.
Surely there are a few more disadvantages coming from the cache store, but like most of the tools that are currently used, this is not a golden hammer to fix any problem but a tool for a particular case.

So, resuming this in a nutshell

A common search engine that could be found in many apps.
Identify a way to make it faster.
Find a third factor, a data source, that could help to achieve it.
Use Redis mixed with a known framework like Spring.
Whoala! Run and see results.

Here is the app repo.

JesusIgnacio / grapefruit

Redis with Spring cache for fast search results

Note: Yes, I called it Grapefruit , nothing to do with the app objective but I found refreshing to call my repos as fruits.

This is all by now, I hope you could enjoy this article as I enjoy writing it, and thank you for your time in reading it.
If you have any questions, please let me know.
Best to you!

This post is in collaboration with Redis.

Breaking a request software design and falling in a Redis-ing perspective.

Thinking out code — Fri, 24 Jun 2022 21:14:30 +0000

Once upon an app…

Nowadays, systems data flow must be efficient and needs to do more with simplicity. Common ways of building modern apps are missing that point, oriented to dependent layers and cohesion between components. In this article, we'll discover an app with those failures in its data flow and split it into smaller pieces to resolve using the advantages of Event-Driven Architecture by the magic of Redis-ing it with Redis.

Supposing the scenario of making a login module, to filter access to our main application pointing to three objectives:

Security authorization 📝
Session storage📝

Which will be the entities related and their behavior?

How would be the data flow?

Login
- User send its user/password.
- The security module valid credentials.
  - affirmative case
    - Authorization granted to home page.
    - The session storage create a session related to the user.
  - negative case
    - Unauthorized.
Logout
- User request
- Session deleted

Flow would like:

Session stored ✅
Credentials validated ✅

Well, apparently have cover all , this is ready for production!

Oh wait!

I could forget something. A first perspective looks like a normal login flow but there are a few questions to answer:

Could I integrate concurrent user sessions and limit them?
What about expired sessions?

I mean, this current solution could work, but what about those scenarios:

If the expired session is a must, where do I mark the expired date to remove expired sessions? Which method has this responsibility? The app? A database trigger? An elf that lives inside the app working extra hours to check all the sessions and remove it?
What about the limit of sessions? If the app has restarted, how would it know how many session has every user? Which of them are the older ones?

Fortunately, in this article exist a solution for every of mentioned problems.

Event-Driven Design to put things in order

EAD is a paradigm about decoupling modules and layers pointing to making independence between them. Left behind the request-driven design, now the events will be the core of the structure, making them event dependents.

What would be out core events?

A session was created.
A session was expired.
A session was deleted.

Besides the events, EAD must specify which will be the event consumer, the producer, and the channel, to interact with them.

Let’s identify what will be our flow

As shown above, the app will be informed about session events, being the event consumer and the event producer, being subscribed to the event channel, so:

A session expired? The app has informed.
A session created? The app has informed.
A session deleted? The app has informed.
How many sessions exist per user? Even if the app was restarted. The app will know it.

Our design resolves our raised problems, but how to bring it to reality?

A Redis-ing perspective

Redis technologies bring a lot of tools to confront data flow problems effectively and simply, from storing a key-value object to providing custom configurations in the related process of it based on its structure, indexing, and lifecycle.

Will use one of them:

Redis Pub/Sub

Redis could work as an event channel, being the event source in our design, making use of PUBLISH and SUBSCRIBE commands. Those could be executed through the Redis console as follows:
```
SUBSCRIBE {channel1} ...{channelN}
```
The subscribe command executes an active listening to a specific channel, then Redis will inform all channel subscribers when a message has been published.
```
PUBLISH {channel1} {message}
```
While the publish command, put a new message in an specific channel.

This tool is the implementation of Publish/Subscribe message paradigm.

Let’s bring the code!

Now, we’ll build a simple app web trough Spring initializr with these dependencies:

Spring Web To make our project a web application, for this instance, we create a simple home page structure, to be the home app representation, called index.html. It must be stored in the /templates/static folder. The HTML looks like that:

<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
  <title>Home</title>
  <link href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0-beta/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-/Y6pD6FV/Vv2HJnA6t+vslU6fwYXjCFtcEpHbNJ0lyAFsXTsjBbfaDjzALeQsN6M" crossorigin="anonymous">
  <link href="https://getbootstrap.com/docs/4.0/examples/signin/signin.css" rel="stylesheet" crossorigin="anonymous"/>
</head>
<body class="d-flex flex-column h-100">
    <main class="flex-shrink-0">
      <div class="container">
        <h1 class="mt-5">This is Home!</h1>
        <a href="/logout">Take me out, please.</a>
      </div>
    </main>
</body>
</html>

Spring Security

A security framework you can complex as you need it. It could look cumbersome when you’re starting using it, but with constant practicing and an understanding of the filter logic, You’ll have a great tool to work with spring environments with the pass of the time.

@EnableWebSecurity
public class SecurityConfig<S extends Session>   {

    @Autowired
    private FindByIndexNameSessionRepository<S> sessionRepository;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
          .authorizeRequests()
            .anyRequest().authenticated()
              .and()
          .formLogin()
              .and()
          .sessionManagement()
            .maximumSessions(3)
                    .sessionRegistry(sessionRegistry())
                    .expiredUrl("/login");
            return http.build();
        }

        @Bean
        public SpringSessionBackedSessionRegistry<S> sessionRegistry() {
            return new SpringSessionBackedSessionRegistry<>(sessionRepository);
        }

        @Bean
        public UserDetailsService userDetailsService() {
            UserDetails user = User.withDefaultPasswordEncoder()
                    .username("user")
                    .password("password")
                    .build();
            return new InMemoryUserDetailsManager(user);
        }   
}

As shown, I declared a simple class with EnableWebSecurity annotation. Inside it, a block with the specification of allowing any authenticated request; detail a default form login for users.
It configures a custom session management, to integrate the Redis library by session registry, being responsible of count sessions per user and establishing an expired time for each one.
If a user exceeds the session max limit session, the older session will be deleted and the current will be created. When a Redis session has expired, the user will be redirected to the login page.
Finally, a bean to mockup user access data called userDetailsService.

Spring Data Redis

A library to integrate spring sessions with Redis with the EnableRedisHttpSession annotation which specifies max inactive seconds by session and a custom Redis namespace to store our session values in the Redis database.
The JedisConnectionFactory bean serves as a connector library between Redis and the spring framework.

@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 15, redisNamespace = "WATERMELON")
    public class RedisConfig {

        @Bean
        public JedisConnectionFactory connectionFactory() {
            RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
            configuration.setHostName("yourHost");
            configuration.setPassword("yourPassword");
            configuration.setUsername("yourUsername");
            configuration.setPort(yourPort);
            return new JedisConnectionFactory(configuration);
        }

    }

Our dependencies pom must look like:

...
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-data-redis</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.9.0</version>
        </dependency>
</dependencies>

In this instance, we could execute the app combined with a local Redis server, but to approach the Redis cloud environment, we’ll integrate with it.

A reliable cloud environment

First of all, we go to redislab

After the register step and login into the environment you’ll access to a page like:

With the example database created as default with a memory available for testing. After this, click it example-database link

To see general configs database as endpoint , username and password, to configure your JedisClient.

Spring Data Redis has a validation when the app is starting to validate if database configuration is accessible, so if your properties are correct, it wouldn't be errors related.

Now , the original flows looks like this:

There are 2 scenarios I invited you to test:

Login in a new session , after have 3 existing sessions, to see how the oldest session is deleted and a new one is created.
Let N seconds of none interaction with your home page application, to see how works Redis expiring sessions.

The code project could be found on watermelon_repo

This is all by now, I hope you could enjoy this article as I enjoy writing in. If you have any questions, please let me know.

Best to you!

This post is in collaboration with Redis.

Finding Luke through the command line by consuming an API

Thinking out code — Fri, 08 Apr 2022 11:55:25 +0000

In the last chapter of this series, I need to find a Starwars word related, in the response of an API, a rarely need, yes.

I have to find the word Luke in a known Starwars API, called Swapi, without IDEs, or frameworks but I’ll use the last chapter's pieces of knowledge

Having the next class:

public class SearchingInStarWarsFor {

    public static void main(String[] args) {
        if (args.length > 0)
            StarWarsWordFinder.searchingFor(args[0]);
    }
}

This StarWarsWordFinder has next specifications:

Execute a request(GET) to the Swapi(people scope).
It searches if the API body response would contain my searched word.

To achieve both objectives, I only need the JDK library that contains:

java.net package that contains:
- URI → to adressing the request.
- http sub-package with:
  - HttpClient → to send request and retrieve it response.
  - HttpRequest → to build a request.
  - HttpResponse → response object.

Getting a similar code like this:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class StarWarsWordFinder {

    static final String STARWARS_URL_PEOPLE_API = "https://swapi.dev/api/people";
    static int foundTimes = 0;

    public static void searchingFor(String word) {
        HttpClient httpClient = HttpClient.newHttpClient();
        HttpRequest httpRequest = HttpRequest
                .newBuilder(URI.create(STARWARS_URL_PEOPLE_API))
                .GET()
                .build();
        httpClient.sendAsync(httpRequest, HttpResponse.BodyHandlers.ofString())
                      .thenApply(HttpResponse::body)
                        .thenAccept(results -> searchingIn(results, word))
                        .join();
        System.out.println(String.format("%s was found %s times", word,  foundTimes));
    }

    static void searchingIn(String results, String arg) {
        if (results.contains(arg))
            foundTimes++;
    }
}

I compile this source to generate a Library as explained in Creating a Java Library chapter, and I run the following terminal command:

java -cp .\starWarsWordFinder.jar .\SearchingInStarWarsFor.java Luke
#it prints
Luke was found 1 times

Let’s try with Yoda:

java -cp .\starWarsWordFinder.jar .\SearchingInStarWarsFor.java Yoda         
#it prints
Yoda was found 0 times

Oh! “Forget someone seems the API...”🤣

Let’s try with Vader:

java -cp .\starWarsWordFinder.jar .\SearchingInStarWarsFor.java Vader         
#it prints
Vader was found 1 times

“I’m your API Daddy...” Ok, enough of older StarWars jokes!

Let's try something else, backing to the code of the library. I could add an external library, to convert API string json response to an object, making it a little more specific in terms of only people's name scope.

The Gson library could parse the string response to a JSON.

Let’s see the source of StarWarsWordFinder code after adding Gson’s fromJson() method:

import com.google.gson.Gson;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;

public class StarWarsWordFinderWithGson {

    //same as last version class

    static void searchingIn(String results, String arg) {
        Gson gson = new Gson();
        StarWarsPeople starWarsPeople = gson.fromJson(results, StarWarsPeople.class);
        for(StarWarsPerson starWarsPerson: starWarsPeople.getResults()) {
            if (starWarsPerson.getName().contains(arg))
                foundTimes++;
        }
    }

    class StarWarsPeople {
        private List<StarWarsPerson> results;
        public List<StarWarsPerson> getResults() {
            return results;
        }
    }

    class StarWarsPerson {
        private String name;
        public String getName() {
            return name;
        }
    }
}

It was necessary to create two additional classes:

StarWarsPeople
StarWarsPerson

To map the string results to the valid structure.

So, running the following commands:

javac -cp .\gson-2.9.0.jar  -d build .\StarWarsWordFinderWithGson.java #to get .class files
jar --create --file starWarsWordFinder.jar .\StarWarsWordFinderWithGson.class '.\StarWarsWordFinderWithGson$StarWarsPeople.class' 
'.\StarWarsWordFinderWithGson$StarWarsPerson.class' #to create the jar file

I get the new version of my library StarWarsWordFinderWithGson then I can run the main class, adding 2 jars, the gson and the starWarsWordFinder libraries:

java -cp "starWarsWordFinder.jar;gson-2.9.0.jar" .\SearchingInStarWarsWithGson.java Luke
#it prints
Luke was found 1 times

So, resuming this in a nutshell

A word needs to be found.
Identify tools inside JDK library to achivet it.
Build a java library with it.
Instance and call it inside our main program.
Compile it and running it
Make some starwars boring joke...ok. no.

This is the end of handmade series , I covered:

Run a Java program with related jar.
Create a jar.
Build a service using a known framework.
Consume an API, create a jar and use it to build a word finder java program.

I hope you enjoyed it like I enjoyed writing it. There are a lot more coming soon.

Tech stack

Java 11.
Windows 10.

Repo

https://github.com/JesusIgnacio/starwars-word-finder

Build a rest service from the command line, as simple as “every request has a response.”

Thinking out code — Mon, 28 Mar 2022 12:20:48 +0000

Following with Handmade Series with Java, this is the 3rd chapter. I’ll make a rest service, as always, step by step, without IDEs.

I'll use the Spark library to getting a “pong” to every “ping” request.

I declare a simple class called PingPongGame with main method inside.

public class PingPongGame {
    public static void main(String[] args) 
            //nothing inside yet
    }
}

Inside of the main method, call a static method named get , provided by Spark library, that contains:

A url path /ping.
GET verb http.
Receiving a req and res object from request.
Which finally return a response, a simple string “pong”.

I add the current import from Spark library spark.Spark.get, getting the code above:

import static spark.Spark.get;

public class PingPongGame {
    public static void main(String[] args) {
        get("/ping", (req, res) -> "pong!");
    }
}

Before executing it, download the spark library, from the maven repository.

After downloading it, place it inside PingPongGame class folder, it runs the next instruction through the command line

java -cp .\spark-core-2.9.3.jar .\PingPongGame.java
#it prints
Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory
        at spark.Service.<clinit>(Service.java:58)
        at spark.Spark$SingletonHolder.<clinit>(Spark.java:54)
        at spark.Spark.getInstance(Spark.java:58)
        at spark.Spark.<clinit>(Spark.java:64)
        at HelloWorld.main(HelloWorld.java:5)
Caused by: java.lang.ClassNotFoundException: org.slf4j.LoggerFactory
        at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:581)
        at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
        at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
        at spark.Service.<clinit>(Service.java:58)
        at spark.Spark$SingletonHolder.<clinit>(Spark.java:54)
        at spark.Spark.getInstance(Spark.java:58)
        at spark.Spark.<clinit>(Spark.java:64)
        at HelloWorld.main(HelloWorld.java:5)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.base/java.lang.reflect.Method.invoke(Method.java:566)
        at jdk.compiler/com.sun.tools.javac.launcher.Main.execute(Main.java:404)
        at jdk.compiler/com.sun.tools.javac.launcher.Main.run(Main.java:179)
        at jdk.compiler/com.sun.tools.javac.launcher.Main.main(Main.java:119)

Cause Spark library by itself can’t run this instance, it depends on others libraries. The required jar libraries list:

slf4j-api
spark-core
javax.servlet-api
jetty-server
jetty-util
jetty-http
jetty-io
log4j-slf4j-impl
log4j-api
log4j-core

After downloading them, run the long command line above:

java -cp "spark-core-2.9.3.jar;slf4j-api-1.7.25.jar;
javax.servlet-api-3.1.0.jar;jetty-server-9.4.31.v20200723.jar;
jetty-util-9.4.31.v20200723.jar;jetty-http-9.4.31.v20200723.jar;
jetty-io-9.4.31.v20200723.jar;log4j-slf4j-impl-2.17.2.jar;
log4j-api-2.17.2.jar;log4j-core-2.17.2.jar" .\PingPongGame.java
#It prints nothing because the process has started to run, leaving the terminal in a waiting state.

So, at this point, I need to verify if the rest service is “up & running” by executing this command:

curl http://localhost:4567/ping
#it should prints
pong!

Again, simple and effective, perhaps not too simple cause of the amount of added libraries, but still isn't to worry taking in count it made without IDEs.

That’s all!

Pong to my ping needed.
Creating a standar rest services.
Using a method of a knowing library.
Add it and test it.
Problem happened(missing libraries).
Adding missing libraries.
Problem fixed.
I got my pong trought rest service.

Command and options dictionary:

java run .class and .java files.
-cpindicate compiled folders directory(classpath).
curl command to execute transfer to or from a server.

Tech stack

Java 11.
Windows 10.
Spark-java.

Repo

https://github.com/JesusIgnacio/every-ping-has-a-pong

Bonus track

Spark-java is a “microframework” as springboot but only based on functional programming with a simple implementation, I invited you to take in count in your read list the next article, to a deeper understanding.

Web microservices development in Java that will Spark joy

Creating a java library, a place where any problem can be resolved.

Thinking out code — Mon, 21 Mar 2022 12:39:14 +0000

Starting with the next class, called SummerDelivery, a delivery service planned to refresh a hot summer day...

public class SummerDelivery {

    public static void main(String[] args) {
        for (String order: args) {
            switch(order) {
                case "PEACH_TENTATION":
                    System.out.println("Peach Tentation Order...");
                    //Anyone knows how to prepared it?
                    break;
                case "FROZEN_APPLE":
                    System.out.println("Frozen Apple Order...");
                    //Anyone knows how to prepared it?
                    break;
                default:
                    System.out.println("Unexpected Order...");
                    break;
            }
        }   
    }
}

But if we running the command to order a PEACH_TENTATION or a FROZEN_APPLE:

➜ java .\SummerDelivery.java PEACH_TENTATION FROZEN_APPLE
#it prints
Peach Tentation Order...
Frozen Apple Order...

The program doesn’t know how to prepare one of its offered beverages, it needs a source with beverages preparation knowledge.

So, having the source below, capable of resolving SummerDelivered needs, called TropicalJuice:

public class TropicalJuice {

    class Storage {
        public static final String PEACH_JUICE = "Peach juice";
        public static final String APPLE_JUICE = "Apple juice";
        public static final String LIMON_JUICE = "Limon juice";     
    }

    class Fridge {
        public static final String ICE_CUBES = "Ice cubes";
        public static final String CHERRY = "Cherry";
        public static final String LIMON_SHOT = "Limon shot";       
    }

    public class JuiceMan {
        public void preparePeachTentation() {
            System.out.println(String.format("Mixing a 250ml of %s with a %s and a few crushed %s.", 
                Storage.PEACH_JUICE, Fridge.LIMON_SHOT, Fridge.ICE_CUBES));
        }

        public void prepareFrozzenApple() {
            System.out.println(String.format("Mixing a 250ml of %s with 2 parts of crushed %s adding 100ml of %s.", 
                Storage.APPLE_JUICE, Fridge.ICE_CUBES, Storage.LIMON_JUICE));
        }
    }
}

It's necessary to include it inside SummerDelivery class to attend juice orders.

First of all, we compile TropicalJuice to a class file, executing the command below:

➜ javac -d . .\TropicalJuice.java
#it generates TropicalJuice.class,TropicalJuice$Fridge.class,TropicalJuice$JuiceMan.class,TropicalJuice$Storage.class

After, we package their .class files generated in a storage called tropical.jar, our java library, running the command below:

➜ jar --create --file tropical.jar .\TropicalJuice.class '.\TropicalJuice$Fridge.class' '.\TropicalJuice$JuiceMan.class' '.\TropicalJuice$Storage.class'
#it generates a jar called tropical.jar

With the created tropical.jar, we add to SummerDeliver class the library new methods.

public class SummerDelivery {
    private static TropicalJuice tropicalJuice = new TropicalJuice();
    private static TropicalJuice.JuiceMan juiceMan = tropicalJuice.new JuiceMan();

    public static void main(String[] args) {
        for (String order: args) {
            switch(order) {
                case "PEACH_TENTATION":
                    System.out.println("Peach Tentation Order...");
                    juiceMan.preparePeachTentation();
                    break;
                case "FROZZEN_APPLE":
                    System.out.println("Frozen Apple Order...");
                    juiceMan.prepareFrozzenApple();
                    break;
                default:
                    System.out.println("Unexpected Order...");
                    break;
            }
        }   
    }
}

Adding the library in the first executed command:

➜ java -cp .\tropical.jar .\SummerDelivery.java FROZZEN_APPLE PEACH_TENTATION WATER
#it prints
Frozen Apple Order...
Mixing a 250ml of Apple juice with 2 parts of crushed Ice cubes adding 100ml of Limon juice.
Peach Tentation Order...
Mixing a 250ml of Peach juice with a Limon shot and a few crushed Ice cubes.
Unexpected Order...

Yep! Now SummerDelivery knows how to refresh this summer! But it still doesn’t know how to serve a Water glass. If you know how to resolve it, please feel free to add it and test it to practice.

That’s all!

A problem happened.
We create a solution to solve it.
Package the solution as a library.
Add it and test it.
Problem fixed.

Command and options dictionary:

java run .class and .java files.
javaccompile .java files and creates .class files.
-dindicate output folder.
-cpindicate compiled folders directory(classpath).
jar to execute actions related to java libraries.
—create indicate jar action command.
—file indicates a name file.

Tech Stack:

Java 11.
Windows 10.

Repo:

https://github.com/JesusIgnacio/summer-delivery

The simple and satisfiying art of executing a java file from the command line.

Thinking out code — Sat, 19 Feb 2022 12:52:02 +0000

Having the next java source

public class Salad {

    public static void main(String[] args) {
        System.out.println("I'm the best salad in this neighberhood!");
    }
}

Run the command below, inside the folder source with java command:

java Salad.java
#it prints
I'm the best salad in this neighberhood!

Now let’s create another Java file in the same folder.

public class Watermelon {

    public void talk() {
        System.out.println("I'm the best fruit!");
    }
}

and call its method talk in Salad class contained in Salad file.

public class Salad {

    public static Watermelon watermelon = new Watermelon();

    public static void main(String[] args) {
        watermelon.talk();//here
        System.out.println("I'm the best salad in this neighberhood!");
    }
}

Let’s run the previous command once again.

java Salad.java
#it prints
Salad.java:3: error: cannot find symbol
        public static Watermelon watermelon = new Watermelon();
                      ^
  symbol:   class Watermelon
  location: class Salad
.\Salad.java:3: error: cannot find symbol
        public static Watermelon watermelon = new Watermelon();
                                                  ^
  symbol:   class Watermelon
  location: class Salad
2 errors
error: compilation failed

Because our Salad class doesn’t know any about the Watermelon class, thought the Watermelon class contained inside the Watermelon file knows how to talk, so let’s add some watermelon to our salad.

At first, is neccesary to process our Watermelon file into our processedFruits folder with the javac command and -d option to indicate folder location name.

javac -d processedFruits Watermelon.java

And finally, let’s add our processedFruits folder to the original run command adding the -cp option to indicate where are compiled our java source of Watermelon file.

java -cp "processedFruits\" Salad.java
#it prints
I'm the best fruit!
I'm the best salad in this neighberhood!

That’s it, simple but effective:

Run a standalone java file.
Run a standalone java file adding compiled sources as need it.

Command and options dictionary:

java run .class and .java files.
javaccompile .java files and creates .class files.
-dindicate output folder.
-cpindicate compiled folders directory(classpath).

Tech stack

Java 11.
Windows 10.

Repo

https://github.com/JesusIgnacio/salad-java-program

A coding maintainable life balance

Thinking out code — Sat, 16 Jan 2021 18:38:13 +0000

Programming is like solving a puzzle or building a structure, you would never be bored if you are a creative type of person who loves to get involved with the building process and the final result but sometimes it turned into a frustrated and exhausting process but never forget that programming has to be fun, free to be, inspiring and simple. Fun to build, free to choose a way to solve a problem, inspiring to do the best we can, and simple to implement.

Despite some programmers saying that coding is always a frustrating, stressful activity, it doesn’t! All human activities have a part of that, n’ coding it’s not the exception but its a beautiful experience like make a great dish for a passionate chef or execute a surgery for a talented doctor and when it turns into a stressful activity, take a break, get a cup of something, make a draw, express yourself in other ways, listen to some music, play a game, take a short walk, n’ go back later it helps, sometimes pushing n’ again, isn’t the correct way, programming is, first of all, a creative process, get used to it to see it in that way.

Nowadays is very common to wrap this beautiful activity with money/project deadlines, pay bills needs, but is necessary to give its time and space for our brain to processing and get the best results and most important a coding maintainable life balance.

DEV Community: Thinking out code

Speed up your search app with Redis

Hands-on code

The problem of search the same thing over and over again

A possible new improvement…

Making it real with Spring and Redis cache integration

Redis also :

Let’s update our code

How works @Cacheable in terms of Redis?

175 ms! More than 70% of improvement.

Happy Lisa Simpson GIF - Find & Share on GIPHY

Oh yeah! This looks really good but what about the cons?

So, resuming this in a nutshell

JesusIgnacio / grapefruit

Redis with Spring cache for fast search results

This post is in collaboration with Redis.

Breaking a request software design and falling in a Redis-ing perspective.

Once upon an app…

How would be the data flow?

Oh wait!

Event-Driven Design to put things in order

A Redis-ing perspective

Let’s bring the code!

A reliable cloud environment

Finding Luke through the command line by consuming an API

Build a rest service from the command line, as simple as “every request has a response.”

Creating a java library, a place where any problem can be resolved.

The simple and satisfiying art of executing a java file from the command line.

Command and options dictionary:

Tech stack

Repo

A coding maintainable life balance

How works `@Cacheable` in terms of Redis?