DEV Community: Carlos A. Martinez

Strategy Pattern

Carlos A. Martinez — Thu, 20 Nov 2025 02:46:38 +0000

What is strategy pattern ?

Strategy is a behavioral design pattern that lets you define a family of algorithms, put each of them into a separate class, and make their objects interchangeable.

How it works

Strategy Interface: A common interface or abstract class is defined to represent the algorithm's behavior.

Concrete Strategies: Concrete classes implement the strategy interface, providing a specific algorithm or behavior. Each concrete strategy encapsulates a particular way to perform a task.

Context: The context is the class that uses a strategy. It holds a reference to a strategy object and delegates the task to it instead of executing the logic itself. The context can be configured with a different strategy object at runtime.

Client: The client code is responsible for creating the context and choosing which concrete strategy to pass to it.

Why Use Strategy Pattern?

It helps you:

✔ Remove long if/else or switch blocks
✔ Isolate different behaviors into separate classes
✔ Add new behaviors without modifying existing code (Open/Closed Principle)
✔ Make your application cleaner, modular, testable, and extendable

Real-Life Example

Think of a payment service:
Pay with PayPal
Pay with Credit Card
Pay with Google Pay

Without Strategy Pattern → you'd write big conditional logic.

With Strategy Pattern → you create a separate “strategy” class for each payment type.

Source information

SourceCode StrategyPattern Github

Programming reactive

Carlos A. Martinez — Sat, 12 Jul 2025 00:36:55 +0000

Spring Boot 3 Redis

Carlos A. Martinez — Tue, 10 Jun 2025 22:49:35 +0000

What is Redis ?

Redis is an open-source, in-memory NoSQL key-value store primarily used for caching, session storage, and message brokering. It stores data in RAM, which enables extremely fast read and write operations compared to traditional disk-based databases

Here's a more detailed breakdown:

In-memory Data Store:

Redis stores data in memory, making it significantly faster than disk-based databases.

NoSQL Key-Value Store:

Redis is a NoSQL database, meaning it doesn't adhere to the traditional relational database model. It uses a key-value pair structure, where each key maps to a value.

Caching:

Redis is commonly used as a cache to speed up applications by storing frequently accessed data in memory.

Session Storage:

It can store user session data, providing a fast and efficient way to manage sessions in web applications.

Message Broker:

Redis can also act as a message broker, allowing different parts of an application to communicate with each other.

Data Types:

Redis supports various data types, including strings, lists, sets, streams, and hashes, allowing for a wide range of data storage and manipulation.

Open Source and Enterprise Versions:

Redis is available as an open-source project and also has a commercial version (Redis Enterprise) that offers additional features and supports.

Redis official

Let's go to create new project spring boot.

spring initializr

Clone repo

Configuration Redis in Spring Boot Application

package com.example.redislearn.settings;

import com.example.redislearn.product.dto.ProductDto;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;

@Configuration  // Marks this class as a Spring configuration class
public class RedisConfig {
    @Bean  // Defines a Spring bean for RedisCacheManager
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        // Define cache configuration
        RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10)) // Set time-to-live (TTL) for cache entries to 10 minutes
                .disableCachingNullValues() // Prevent caching of null values
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new Jackson2JsonRedisSerializer<>(ProductDto.class))); // Serialize values using Jackson JSON serializer

        // Create and return a RedisCacheManager with the specified configuration
        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(cacheConfig) // Apply default cache configuration
                .build();
    }
}

Services

package com.example.redislearn.product.services;

import com.example.redislearn.product.dto.ProductDto;
import com.example.redislearn.product.entity.Product;
import com.example.redislearn.product.repository.ProductRepository;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    @CachePut(value="PRODUCT_CACHE", key="#result.id")
    public ProductDto createProduct(ProductDto productDto) {
        var product = new Product();
        product.setName(productDto.name());
        product.setPrice(productDto.price());

        Product savedProduct = productRepository.save(product);
        return new ProductDto(savedProduct.getId(), savedProduct.getName(),
                savedProduct.getPrice());
    }


    @Cacheable(value="PRODUCT_CACHE", key="#productId")
    public ProductDto getProduct(Long productId) {
        Product product = productRepository.findById(productId)
                .orElseThrow(() -> new IllegalArgumentException("Cannot find product with id " + productId));
        return new ProductDto(product.getId(), product.getName(),
                product.getPrice());
    }

    @CachePut(value="PRODUCT_CACHE", key="#result.id")
    public ProductDto updateProduct(ProductDto productDto) {
        Long productId = productDto.id();
        Product product = productRepository.findById(productId)
                .orElseThrow(() -> new IllegalArgumentException("Cannot find product with id " + productId));

        product.setName(productDto.name());
        product.setPrice(productDto.price());

        Product updatedProduct = productRepository.save(product);
        return new ProductDto(updatedProduct.getId(), updatedProduct.getName(),
                updatedProduct.getPrice());
    }

    @CacheEvict(value="PRODUCT_CACHE", key="#productId")
    public void deleteProduct(Long productId) {
        productRepository.deleteById(productId);
    }
}

Hello world - API Gateway AWS

Carlos A. Martinez — Sat, 30 Mar 2024 23:31:17 +0000

Create, maintain, and secure APIs at any scale.

Amazon API Gateway is a fully managed service that makes it easy for developers to create, publish, maintain, monitor, and secure APIs at any scale. APIs act as the "front door" for applications to access data, business logic, or functionality from your backend services. Using API Gateway, you can create RESTful APIs and WebSocket APIs that enable real-time two-way communication applications. API Gateway supports containerized and serverless workloads, as well as web applications.

1 million API calls received free

How API Gateway works

Benefits

Efficient API development
Performance at any scale
Cost savings at scale
Easy monitoring
Flexible security controls
RESTful API options

Get started - example

REST API > Build

Create API
API name: first-API-Gateway

Create resource

Resource name: hello-world-API

Edit integration response > Mapping templates

{
    "message": "Hello world from API Gateway"
}

Save

Deploy

api-gateway

Web Scraping

Carlos A. Martinez — Tue, 10 Oct 2023 01:44:47 +0000

Web Scraping

Web scraping, web harvesting, or web data extraction is data scraping used for extracting data from websites.

Web Crawling

A Web crawler, sometimes called a **spider **or **spiderbot **and often shortened to crawler, is an Internet bot that systematically browses the World Wide Web and that is typically operated by search engines for the purpose of Web indexing (web spidering).

Prosecuting Computer Crimes

Robots.txt

robots.txt is the filename used for implementing the Robots Exclusion Protocol, a standard used by websites to indicate to visiting web crawlers and other web robots which portions of the website they are allowed to visit.

Example: https://booking.com/robots.txt

Web Scraping Sandbox

download_page.py

import requests
from bs4 import BeautifulSoup

URL = 'https://toscrape.com/'

web_scraping_sandbox = requests.get(URL)

web_scraping_sandbox.status_code 
# output --> 200

web_scraping_sandbox.text

# output -->
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Scraping Sandbox</title>
        <link href="./css/bootstrap.min.css" rel="stylesheet">
        <link href="./css/main.css" rel="stylesheet">
    </head>
    <body>
        <div class="container">
            <div class="row">
                .
                .
                .
            </div>
        </div>
    </body>
</html>

web_scraping_sandbox.headers
# output --> 
{'Date': 'Fri, 13 Oct 2023 02:20:03 GMT', 'Content-Type': 'text/html', 'Content-Length': '3939', 'Connection': 'keep-alive', 'Last-Modified': 'Wed, 08 Feb 2023 21:02:33 GMT', 'ETag': '"63e40de9-f63"', 'Accept-Ranges': 'bytes', 'Strict-Transport-Security': 'max-age=0; includeSubDomains; preload'}

web_scraping_sandbox.request.method
# output --> Method: GET

Adding BeautifulSoup

soap = BeautifulSoup(web_scraping_sandbox.text, 'lxml')
print(type(soap))
# output --> <class 'bs4.BeautifulSoup'>

print(soap.find('h2'))
# output --> <h2>Books</h2>

Under Construction

Azure Storage Explorer

Carlos A. Martinez — Sun, 16 Jul 2023 03:06:06 +0000

Manage your cloud storage on Azure

Ease cloud storage management and boost productivity

Upload, download, and manage Azure Storage blobs, files, queues, and tables, as well as Azure Data Lake Storage entities and Azure managed disks. Configure storage permissions and access controls, tiers, and rules.

Download Storage Explorer

Learn Storage Explorer

In your Storage account go to -> Security + networking -> Access keys and copy Storage account name and Connection string

Display name: Storage account name
Connection string: Connection string

And Next and finally you have success connection with Storage Account

Thanks for taking your time to read this post.

Azure Functions Vs Code

Carlos A. Martinez — Thu, 29 Jun 2023 23:54:55 +0000

Azure Functions for Visual Studio Code

Install Extension

Create Function

Choose folder that will contain your function project

Select a language

Select a Javascript programming model

JS Model

Select a template for your projects first function

Function name

Finished creating project

Deploy function

Before that must create new function App in Portal Azure

Select azureFunctionTestC4rlos

Deploy function

Review

Test/Run

Get function URL

Thanks for taking your time to read this post.

Source

Azure Data Factory LAB Copy CSV

Carlos A. Martinez — Tue, 13 Jun 2023 19:12:28 +0000

Azure Data Factory is the platform that solves such data scenarios. It is the cloud-based ETL and data integration service that allows you to create data-driven workflows for orchestrating data movement and transforming data at scale. Using Azure Data Factory, you can create and schedule data-driven workflows (called pipelines) that can ingest data from disparate data stores. You can build complex ETL processes that transform data visually with data flows or by using compute services such as Azure HDInsight Hadoop, Azure Databricks, and Azure SQL Database.

Lab ADF Copy Data from CSV to CSV

1 STEP

Create a resource group: LAB01_ADF_COPYING_DATA_FROM_CSV_TO_CSV

2 STEP

Create a storage account (blob storage)

Redundancy: Locally-redundant storage (LRS)

3 STEP

Create a storage account (data lake)

Enable hierarchical namespace

4 STEP

Inside blob storage (moviesblobst) add container 'bankmovies'

and after that upload file csv

5 STEP

Config data lake

Linked services

Linked services are much like connection strings, which define the connection information needed for the service to connect to external resources.

Is time to create a Data Factory, here we go.

6 STEP

Name: LAB01ADF01

Launch studio

7 STEP

Create new Linked service to Blob Storage

Name: ls_blob_moviesblobst

Storage account name: moviesblobst
and test connection

8 STEP

Create new Linked service to Data Lake

Name: ls_dl_moviesdatalakee
Storage account name: moviesdatalakee
and test connection

9 STEP

Create 2 dataset origin and sink

Dataset Blob Storage

Dataset > New dataset > Azure Blob Storage > DelimitedText (CSV)

Name: ds_movies_bank_row_bs
Linked service: ls_blob_moviesblobst

File path you can clic in preview data

Dataset Data Lake

Dataset > New dataset > Azure Data Lake Storage Gen2 > DelimitedText (CSV)

Name: ds_movies_bank_raw_dl
Linked service: ls_dl_moviesdatalakee

Validate all and publish all

10 STEP

Generate new pipeline, name is pl_ingestion_movies_data

Activities: Move & transform > Copy data

Copy data movies

Source dataset: ds_movies_bank_row_bs
Sink dataset: ds_movies_bank_raw_dl

Validate check
Debug

Go to data lake and look the file csv with data

Source ADF

Thanks for taking your time to read this post.

Git for Beginners

Carlos A. Martinez — Tue, 09 May 2023 16:37:36 +0000

Git is a free and open-source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. :-)

Setting git 🙂

Command	Description
`git --version`	Git version.
`git config --global user.email ['email']`	Setting email.
`git config --global user.name ['name']`	Setting name.
`git config -l`	Show detail of git settings.
`git config --global color.ui true`	Setting color on git.

Git Commands 🙃

Command	Description
`git init`	Init to repository.
`git status`	shows the state of the working directory and the staging area.
`git add`	Add files to the staging areay 'Tracked'.
`git add .`	Add all files to the staging areay.
`git commit -m ['message']`	Commit files to the local repository.
`git commit -am ['message']`	Add and commit files to the local repository.
`git show`	Shows one or more objects (blobs, trees, tags and commits).
`git log`	Lists the commits made in that repository.
`git log ['file']`	Show commits made in that file specified.
`git log --stat`	Show commits made in that file specified.
`git rm ['folder/file']`	Removes a file from both the repository and the working directory.
`git rm --cache ['folder/file']`	Remove files from staging area.
`git clone ['URL']`	Used to target an existing repository and create a clone.
`git diff ['sha']`	Show changes between commits and staging.
`git diff ['sha'] ['sha']`	Show changes between commits.
`git checkout ['branch-name']`	Switch branches.
`git checkout ['sha']`	Switch restore working tree files.
`git checkout -b ['branch-name']`	Reate and switch branches.
`git tag ['tag-name']`	Tags are ref's that point to specific points in Git history.
`git tag -a v1.4 -m ['version1.4']`	Command will create a new annotated tag identified with v1.4.

Git-branch - List, create, or delete branches 🙂

Command	Description
`git branch ['branch-name']`	Create branch.
`git branch -l`	List branches.
`git branch -d ['branch-name']`	Delete branch.
`git branch -D ['branch-name']`	Forza delete branch.
`git checkout ['branch-name']`	Git-checkout - Switch branches or restore working tree files.
`git checkout ['SHA']`	Git-checkout - Switch commit.
`git checkout -b ['branch-name']`	Create and switch branches.

Git Tags 🙂

Command	Description
`git tag ['tag-name']`	Create tag.
`git tag -l`	List tages.
`git tag -d ['tag-name']`	Delete tag.
`git tag -D ['tag-name']`	Forza delete tag.
`git checkout ['tag-name']`	Git-checkout - Switch tages or restore working tree files.
`git checkout ['SHA']`	Git-checkout - Switch commit.
`git checkout -b ['tag-name']`	Create and switch tages.

💻

$ git tag v0.1.0 // create tag

$ git tag -a v0.1.1 // creat tag with comment

$ git tag // list of tags
v0.1.0

$ git tag -l // list of tags
v0.1.0

$ git tag -l "0.1.*" // filter tags
v0.1.0

$ git tag -d v0.1.0 // delete tag
Delete tag 'v0.1.0' (was 1234234u)

$ git show v0.1.0 // show tags

Git Cherry pick 🙂

Command	Description
`git cherry-pick ['SHA']`	Pick commit

Git rebase 🙂

Command	Description
`git rebase -i --interactive HEAD~#commits`	rebase commits
`git rebase -i --interactive HEAD~#commits`	rebase commits
`git push --force`	force push

$ git rebase -i HEAD~2

pick 9309bf8 Autor: [Carlos Andres Martinez]
s 2438f88 Autor: [Carlos Andres Martinez]

# Rebase ea86eb8..2438f88 onto ea86eb8 (2 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# .       create a merge commit using the original merge commit's
# .       message (or the oneline, if no original merge commit was
# .       specified). Use -c <commit> to reword the commit message.
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

$ git push --force

Git log 🙂

Command	Description
`git log`	show logs
`git log ['file-name']`	show logs
`git log --oneline`	show logs a single line
`git log --oneline --decorate`	show logs a single line

Export commits txt 🙂

git log > commits.txt

git blame ['file-name']

git reflog

thank you for reading

Amazon Simple Storage Service S3 - AWS

Carlos A. Martinez — Mon, 16 Jan 2023 18:09:02 +0000

Amazon Simple Storage Service (Amazon S3) is an object storage service offering industry-leading scalability, data availability, security, and performance. Customers of all sizes and industries can store and protect any amount of data for virtually any use case, such as data lakes, cloud-native applications, and mobile apps. With cost-effective storage classes and easy-to-use management features, you can optimize costs, organize data, and configure fine-tuned access controls to meet specific business, organizational, and compliance requirements.

S3 is SaaS

<< Back to AWS Training

Elastic Block Store EBS - AWS

Carlos A. Martinez — Mon, 16 Jan 2023 18:02:20 +0000

Amazon Elastic Block Store (Amazon EBS) is an easy-to-use, scalable, high-performance block-storage service designed for Amazon Elastic Compute Cloud (Amazon EC2).

EBS is IaaS

<< Back to AWS Training

Elastic Compute Cloud EC2 - AWS

Carlos A. Martinez — Mon, 16 Jan 2023 18:01:29 +0000

Pay as you go

<< Back to AWS Training