Java Spring – Data Storage

import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id


@Entity
data class Product(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0,
    val name: String,
    val price: Double
)

import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository


@Repository
interface ProductRepository : JpaRepository<Product, Long> {
  
    fun findByName(name: String): List<Product>
    
}

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.*

  
@RestController
@RequestMapping("/products")
class ProductController(@Autowired val productRepository: ProductRepository) {

    // Create
    @PostMapping
    fun createProduct(@RequestBody product: Product): Product {
        return productRepository.save(product)
    }

    // Read all
    @GetMapping
    fun getAllProducts(): List<Product> {
        return productRepository.findAll()
    }

    // Read by ID
    @GetMapping("/{id}")
    fun getProductById(@PathVariable id: Long): Product? {
        return productRepository.findById(id).orElse(null)
    }

    // Read by name
    @GetMapping("/search")
    fun getProductsByName(@RequestParam name: String): List<Product> {
        return productRepository.findByName(name)
    }

    // Update
    @PutMapping("/{id}")
    fun updateProduct(@PathVariable id: Long, @RequestBody updatedProduct: Product): Product? {
        return productRepository.findById(id).map { existingProduct ->
            val newProduct = existingProduct.copy(name = updatedProduct.name, price = updatedProduct.price)
            productRepository.save(newProduct)
        }.orElse(null)
    }

    // Delete by ID
    @DeleteMapping("/{id}")
    fun deleteProduct(@PathVariable id: Long) {
        productRepository.deleteById(id)
    }

    // Delete
    @DeleteMapping
    fun deleteProduct(@RequestBody product: Product) {
        productRepository.delete(product)
    }

    // Check existence by ID
    @GetMapping("/exists/{id}")
    fun existsById(@PathVariable id: Long): Boolean {
        return productRepository.existsById(id)
    }

    // Count all products
    @GetMapping("/count")
    fun countProducts(): Long {
        return productRepository.count()
    }
}

// Hibernate-specific configuration (hibernate.cfg.xml)
<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <!-- JDBC connection pool settings ... using built-in test pool -->
        <property name="hibernate.c3p0.min_size">5</property>
        <property name="hibernate.c3p0.max_size">20</property>
        <property name="hibernate.c3p0.timeout">300</property>
        <property name="hibernate.c3p0.max_statements">50</property>
        <property name="hibernate.c3p0.idle_test_period">3000</property>
        <!-- Echo all executed SQL to stdout -->
        <property name="hibernate.show_sql">true</property>
        <!-- Drop and re-create the database schema on startup -->
        <property name="hibernate.hbm2ddl.auto">update</property>
       
        <!-- Names the annotated entity class -->
        <mapping class="com.example.User"/>
    </session-factory>
</hibernate-configuration>

// JPA Entity
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;


@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
}

// JPA Repository
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.transaction.Transactional;

public class UserRepository {
  
    @PersistenceContext
    private EntityManager entityManager;
  
    @Transactional
    public void save(User user) {
        entityManager.persist(user);
    }
    
    public User find(Long id) {
        return entityManager.find(User.class, id);
    }
    
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;


public class JdbcExample {
  
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String username = "root";
        String password = "password";
        try (Connection connection = DriverManager.getConnection(url, username, password);
             Statement statement = connection.createStatement();
             ResultSet resultSet = statement.executeQuery("SELECT id, name FROM users")) {
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                System.out.println("User ID: " + id + ", Name: " + name);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
}

public List<User> getUsers() {
    List<User> users = new ArrayList<>();
    try (Connection connection = DriverManager.getConnection(url, username, password);
         Statement statement = connection.createStatement();
         ResultSet resultSet = statement.executeQuery("SELECT id, name FROM users")) {
        while (resultSet.next()) {
            User user = new User();
            user.setId(resultSet.getInt("id"));
            user.setName(resultSet.getString("name"));
            users.add(user);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return users;
}

public List<User> getUsers() {
    EntityManager em = entityManagerFactory.createEntityManager();
    return em.createQuery("SELECT u FROM User u", User.class).getResultList();
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    implementation 'com.h2database:h2' // H2 for testing
}

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;


@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // getters and setters
}

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;
import javax.transaction.Transactional;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;


@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional
    public void createUser(String name) {
        User user = new User();
        user.setName(name);
        userRepository.save(user);
    }

    public List<User> getAllUsersJPA() {
        return userRepository.findAll();
    }

    public List<User> getAllUsersJDBC() {
        String sql = "SELECT id, name FROM User";
        return jdbcTemplate.query(sql, new UserRowMapper());
    }

    private static class UserRowMapper implements RowMapper<User> {
        @Override
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
            User user = new User();
            user.setId(rs.getLong("id"));
            user.setName(rs.getString("name"));
            return user;
        }
    }
    
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;


@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/users")
    public void createUser(@RequestParam String name) {
        userService.createUser(name);
    }

    @GetMapping("/users/jpa")
    public List<User> getUsersJPA() {
        return userService.getAllUsersJPA();
    }

    @GetMapping("/users/jdbc")
    public List<User> getUsersJDBC() {
        return userService.getAllUsersJDBC();
    }
    
}

import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Query
import org.springframework.stereotype.Repository


@Repository
interface UserRepository : JpaRepository<User, Long> {
  
    @Query("SELECT u FROM User u WHERE u.name = :name")
    fun findByNameJPQL(name: String): List<User>
    
}

interface UserRepositoryCustom {
    fun findByNameCriteria(name: String): List<User>
}

import org.springframework.stereotype.Repository
import javax.persistence.EntityManager
import javax.persistence.PersistenceContext
import javax.persistence.criteria.CriteriaBuilder
import javax.persistence.criteria.CriteriaQuery
import javax.persistence.criteria.Root


@Repository
class UserRepositoryCustomImpl : UserRepositoryCustom {
  
    @PersistenceContext
    private lateinit var entityManager: EntityManager
  
    override fun findByNameCriteria(name: String): List<User> {
        val criteriaBuilder: CriteriaBuilder = entityManager.criteriaBuilder
        val criteriaQuery: CriteriaQuery<User> = criteriaBuilder.createQuery(User::class.java)
        val root: Root<User> = criteriaQuery.from(User::class.java)
        criteriaQuery.select(root).where(criteriaBuilder.equal(root.get<String>("name"), name))
        val query = entityManager.createQuery(criteriaQuery)
        return query.resultList
    }
    
}

import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository


@Repository
interface UserRepository : JpaRepository<User, Long>, UserRepositoryCustom

dependencies {
    implementation("com.h2database:h2")
}

# H2 Database Configuration
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update

dependencies {
    implementation("mysql:mysql-connector-java")
}

# MySQL Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.jpa.database-platform=org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto=update

dependencies {
    implementation("org.postgresql:postgresql")
}

# PostgreSQL Database Configuration
spring.datasource.url=jdbc:postgresql://localhost:5432/mydatabase
spring.datasource.driverClassName=org.postgresql.Driver
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.hibernate.ddl-auto=update

dependencies {
    implementation("com.oracle.database.jdbc:ojdbc8")
}

# Oracle Database Configuration
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:orcl
spring.datasource.driverClassName=oracle.jdbc.OracleDriver
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.jpa.database-platform=org.hibernate.dialect.Oracle12cDialect
spring.jpa.hibernate.ddl-auto=update

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-data-mongodb")
}

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=mydatabase

import org.springframework.data.annotation.Id
import org.springframework.data.mongodb.core.mapping.Document


@Document(collection = "users")
data class User(
    @Id
    val id: String? = null,
    val name: String,
    val email: String
)

import org.springframework.data.mongodb.repository.MongoRepository
import org.springframework.stereotype.Repository


@Repository
interface UserRepository : MongoRepository<User, String> {
    fun findByName(name: String): User
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.mariadb.jdbc:mariadb-java-client'
    runtimeOnly 'org.springframework.boot:spring-boot-devtools'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

spring.datasource.url=jdbc:mariadb://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MariaDBDialect

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-couchbase'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'com.fasterxml.jackson.module:jackson-module-kotlin'
    implementation 'org.jetbrains.kotlin:kotlin-reflect'
    implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

spring.couchbase.connection-string=127.0.0.1
spring.couchbase.username=your_username
spring.couchbase.password=your_password
spring.couchbase.bucket.name=your_bucket

import org.springframework.context.annotation.Configuration
import org.springframework.data.couchbase.config.AbstractCouchbaseConfiguration


@Configuration
class CouchbaseConfig : AbstractCouchbaseConfiguration() {
    override fun getConnectionString(): String {
        return "127.0.0.1"
    }
    override fun getUserName(): String {
        return "your_username"
    }
    override fun getPassword(): String {
        return "your_password"
    }
    override fun getBucketName(): String {
        return "your_bucket"
    }
}

import com.example.model.User
import org.springframework.data.couchbase.repository.CouchbaseRepository
import org.springframework.stereotype.Repository


@Repository
interface UserRepository : CouchbaseRepository<User, String> {
    fun findByEmail(email: String): List<User>
}

# Connection Pool Configuration
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.max-lifetime=1800000
spring.datasource.hikari.connection-timeout=30000

Isolation Level: | Dirty Read | Non-Repeatable Read | Phantom Read
---------------------------------------------------------------------------------
READ UNCOMMITTED     |       +        |            +           |        +
READ COMMITTED       |       -        |            +           |        +
REPEATABLE READ      |       -        |            -           |        +
SERIALIZABLE         |       -        |            -           |        -

import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Isolation
import org.springframework.transaction.annotation.Transactional


@Service
class MyService {
    @Transactional(isolation = Isolation.READ_UNCOMMITTED)
    fun performReadUncommittedOperation() {
    }
}

@Transactional(propagation = Propagation.REQUIRED)
fun myTransactionalMethod() {

@Transactional(isolation = Isolation.REPEATABLE_READ)
fun myTransactionalMethod() {
    // The code will be executed within a transaction with the REPEATABLE_READ isolation level.
}

@Transactional(timeout = 30)
fun myTransactionalMethod() {
    // The code must be executed within 30 seconds.
}

@Transactional(readOnly = true)
fun myReadOnlyMethod() {
    // The code is executed in read-only mode.
}

@Transactional(rollbackFor = [RuntimeException::class, IOException::class])
fun myMethod() {
    // The transaction will be rolled back if a RuntimeException or IOException is thrown.
}

@Transactional(noRollbackFor = [CustomException::class])
fun myMethod() {
    // The transaction will not be rolled back if a CustomException is thrown.
}

@Transactional(transactionManager = "customTransactionManager")
fun myMethod() {
    // The method will use customTransactionManager
}

@Transactional("customTransactionManager")
fun myMethod() {
    // The method will use customTransactionManager
}

import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Isolation
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional


@Service
class MyService {

    @Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.REPEATABLE_READ,
        timeout = 30,
        readOnly = false,
        rollbackFor = [RuntimeException::class],
        noRollbackFor = [CustomException::class],
        transactionManager = "customTransactionManager"
    )
    fun myTransactionalMethod() {
    }
}

logging:
  level:
    org:
      springframework:
        transaction: DEBUG
      hibernate:
        SQL: DEBUG
        transaction: DEBUG
        type:
          descriptor:
            sql:
              BasicBinder: TRACE

<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml"/>
    <logger name="org.springframework.transaction" level="DEBUG"/>
    <logger name="org.hibernate.SQL" level="DEBUG"/>
    <logger name="org.hibernate.transaction" level="DEBUG"/>
    <logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="TRACE"/>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
}

spring.redis.host=localhost
spring.redis.port=6379

import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.connection.RedisConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.serializer.GenericToStringSerializer


@Configuration
class RedisConfig {

    @Bean
    fun redisTemplate(connectionFactory: RedisConnectionFactory): RedisTemplate<String, Any> {
        val template = RedisTemplate<String, Any>()
        template.setConnectionFactory(connectionFactory)
        template.keySerializer = GenericToStringSerializer(String::class.java)
        template.valueSerializer = GenericToStringSerializer(Any::class.java)
        return template
    }

}

import java.io.Serializable


data class Person(
    val id: String,
    val name: String,
    val age: Int
) : Serializable

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.stereotype.Service


@Service
class PersonService(@Autowired private val redisTemplate: RedisTemplate<String, Any>) {
  
    private val hashKey = "Person"
  
    fun save(person: Person) {
        redisTemplate.opsForHash<String, Person>().put(hashKey, person.id, person)
    }
    
    fun findById(id: String): Person? {
        return redisTemplate.opsForHash<String, Person>().get(hashKey, id)
    }
    
    fun findAll(): List<Person> {
        return redisTemplate.opsForHash<String, Person>().values(hashKey) as List<Person>
    }
    
    fun delete(id: String) {
        redisTemplate.opsForHash<String, Person>().delete(hashKey, id)
    }
    
}

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.*

  
@RestController
@RequestMapping("/persons")
class PersonController(@Autowired private val personService: PersonService) {
  
    @PostMapping
    fun savePerson(@RequestBody person: Person) {
        personService.save(person)
    }
    
    @GetMapping("/{id}")
    fun getPerson(@PathVariable id: String): Person? {
        return personService.findById(id)
    }
    
    @GetMapping
    fun getAllPersons(): List<Person> {
        return personService.findAll()
    }
    
    @DeleteMapping("/{id}")
    fun deletePerson(@PathVariable id: String) {
        personService.delete(id)
    }
    
}

CREATE OR REPLACE FUNCTION notify_table_update()
RETURNS TRIGGER AS $$
BEGIN
    PERFORM pg_notify('table_update', NEW.id::text);
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER table_update_trigger
AFTER UPDATE ON your_table
FOR EACH ROW
EXECUTE FUNCTION notify_table_update();

spring.datasource.url=jdbc:postgresql://localhost:5432/your_database
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.datasource.driver-class-name=org.postgresql.Driver

import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.stereotype.Service
import javax.annotation.PostConstruct


@Service
class NotificationListener(private val jdbcTemplate: JdbcTemplate) {
  
    @PostConstruct
    fun listenForNotifications() {
        Thread {
            try {
                jdbcTemplate.dataSource?.connection?.use { connection ->
                    connection.createStatement().use { statement ->
                        statement.execute("LISTEN table_update")
                    }
                    while (true) {
                        connection.unwrap(org.postgresql.PGConnection::class.java).getNotifications()?.let { notifications ->
                            for (notification in notifications) {
                                println("Received notification: ${notification.parameter}")
                                // Submit a request when you receive a notification
                                sendRequest(notification.parameter)
                            }
                        }
                        Thread.sleep(1000) // Set a delay between checks
                    }
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }.start()
    }
    
    private fun sendRequest(id: String) {
        // Logic for sending a request
        println("Sending request for id: $id")
        // For example, you can use RestTemplate or WebClient to send an HTTP request.
    }

}

spring.data.mongodb.uri=mongodb://localhost:27017/your_database

import com.mongodb.client.MongoClients
import com.mongodb.client.model.changestream.ChangeStreamDocument
import org.bson.Document
import org.springframework.stereotype.Service
import javax.annotation.PostConstruct


@Service
class ChangeStreamListener {

    @PostConstruct
    fun listenForChanges() {
        Thread {
            try {
                MongoClients.create("mongodb://localhost:27017").use { mongoClient ->
                    val database = mongoClient.getDatabase("your_database")
                    val collection = database.getCollection("your_collection")
                    val changeStream = collection.watch()
                    for (change in changeStream) {
                        println("Received change: ${change.fullDocument}")
                        // Send a request when you receive a change
                        sendRequest(change.fullDocument)
                    }
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }.start()
    }

    private fun sendRequest(document: Document?) {
        // Request sending logic
        println("Sending request for document: $document")
        // For example, you can use RestTemplate or WebClient to send an HTTP request.
    }

}

Repository
    ├── CrudRepository
    │     ├── PagingAndSortingRepository
    │     │     ├── JpaRepository
    │     │     └── MongoRepository
    │     └── ReactiveCrudRepository
    │           └── R2dbcRepository

import org.springframework.data.repository.CrudRepository


interface PersonRepository : CrudRepository<Person, Long>

import org.springframework.data.jpa.repository.JpaRepository


interface PersonRepository : JpaRepository<Person, Long>

import org.springframework.data.repository.PagingAndSortingRepository


interface PersonRepository : PagingAndSortingRepository<Person, Long>

import org.springframework.data.mongodb.repository.MongoRepository


interface PersonRepository : MongoRepository<Person, String>

import org.springframework.data.repository.reactive.ReactiveCrudRepository
import reactor.core.publisher.Mono


interface PersonRepository : ReactiveCrudRepository<Person, Long> {
  
    fun findByFirstName(firstName: String): Mono<Person>
    
}

import org.springframework.data.r2dbc.repository.R2dbcRepository
import reactor.core.publisher.Mono


interface PersonRepository : R2dbcRepository<Person, Long> {
  
    fun findByLastName(lastName: String): Mono<Person>
    
}

docker run -p 8080:8080 -p 50000:50000 jenkins/jenkins:lts

docker run -d -p 8081:8081 --name nexus sonatype/nexus3

EXPLAIN SELECT * FROM users WHERE id = 1;

Seq Scan on users
(cost=0.00..35.50 rows=1 width=64)
Filter: (id = 1)

CREATE INDEX idx_users_id ON users (id);

EXPLAIN SELECT * FROM users WHERE id = 1;

Index Scan using idx_users_id on users
(cost=0.28..8.30 rows=1 width=64)
Index Cond: (id = 1)

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'com.h2database:h2'
    implementation 'com.fasterxml.jackson.module:jackson-module-kotlin'
    implementation 'org.jetbrains.kotlin:kotlin-reflect'
    implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

import javax.persistence.*

  
@Entity
@Table(name = "users", indexes = [Index(name = "idx_user_email", columnList = "email")])
data class User(
  
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0,
  
    @Column(nullable = false)
    val name: String,
  
    @Column(nullable = false, unique = true)
    val email: String
  
)

SHOW INDEX FROM users;

import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Isolation
import org.springframework.transaction.annotation.Transactional


@Service
class MyService {

    @Transactional(isolation = Isolation.SERIALIZABLE)
    fun performTransactionalOperation() {
    }

}

-- Transaction A takes a shared lock
BEGIN TRANSACTION;
SELECT * FROM MyTable WITH (HOLDLOCK, ROWLOCK);

import org.springframework.data.jpa.repository.Lock
import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.CrudRepository
import javax.persistence.LockModeType


interface MyRepository : CrudRepository<MyEntity, Long> {

    @Lock(LockModeType.PESSIMISTIC_READ)
    @Query("SELECT e FROM MyEntity e WHERE e.id = :id")
    fun findWithSharedLock(id: Long): MyEntity?

}

-- Transaction B takes an exclusive lock
BEGIN TRANSACTION;
UPDATE MyTable WITH (ROWLOCK) SET Column = 'Value';

import org.springframework.data.jpa.repository.Lock
import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.CrudRepository
import javax.persistence.LockModeType


interface MyRepository : CrudRepository<MyEntity, Long> {

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT e FROM MyEntity e WHERE e.id = :id")
    fun findWithExclusiveLock(id: Long): MyEntity?

}

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import javax.persistence.EntityManager
import javax.persistence.LockModeType


@Service
class MyService @Autowired constructor(
    private val myRepository: MyRepository,
    private val entityManager: EntityManager
) {

    @Transactional
    fun performSharedLockOperation(id: Long) {
        val entity = myRepository.findWithSharedLock(id)
        // Your code is here
    }

    @Transactional
    fun performExclusiveLockOperation(id: Long) {
        val entity = myRepository.findWithExclusiveLock(id)
        // Your code is here
    }

    @Transactional
    fun performExclusiveLockOperationWithEntityManager(id: Long) {
        val entity = entityManager.find(MyEntity::class.java, id, LockModeType.PESSIMISTIC_WRITE)
        // Your code is here
    }

}

import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional


@Service
class MyService {

    @Transactional
    fun executeTransactionalMethod() {
        // Here the code will be executed within the transaction.
    }
    
}

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<tx:advice id="txAdvice">
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="serviceOperation" expression="execution(* com.example.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation"/>
</aop:config>

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.TransactionStatus
import org.springframework.transaction.support.DefaultTransactionDefinition


@Service
class MyTransactionalService(@Autowired private val transactionManager: PlatformTransactionManager) {

    fun executeTransactionalOperation() {
        val transactionDefinition = DefaultTransactionDefinition()
        transactionDefinition.name = "exampleTransaction"
        transactionDefinition.propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRED
        val transactionStatus: TransactionStatus = transactionManager.getTransaction(transactionDefinition)
        try {
            // Executing business logic
            // For example, inserting data into a database
            transactionManager.commit(transactionStatus)
        } catch (ex: Exception) {
            transactionManager.rollback(transactionStatus)
            throw ex
        }
    }
    
}

@Bean
fun transactionManager(dataSource: DataSource): PlatformTransactionManager {
    return DataSourceTransactionManager(dataSource)
}

@Bean
fun transactionManager(entityManagerFactory: EntityManagerFactory): PlatformTransactionManager {
    return JpaTransactionManager(entityManagerFactory)
}

@Bean
fun transactionManager(sessionFactory: SessionFactory): PlatformTransactionManager {
    return HibernateTransactionManager(sessionFactory)
}

@Bean
fun transactionManager(): PlatformTransactionManager {
    return JtaTransactionManager()
}

import org.springframework.stereotype.Service
import org.springframework.transaction.support.TransactionCallback
import org.springframework.transaction.support.TransactionCallbackWithoutResult
import org.springframework.transaction.support.TransactionTemplate
import org.springframework.transaction.TransactionStatus


@Service
class MyService(private val transactionTemplate: TransactionTemplate) {

    fun executeInTransaction() {
        transactionTemplate.execute(object : TransactionCallbackWithoutResult() {
            override fun doInTransactionWithoutResult(status: TransactionStatus) {
                println("Executing in transaction")
                // If needed, you can call status.setRollbackOnly() to roll back the transaction.
                status.rollbackToSavepoint(savepoint)
            }
        })
    }

    fun executeInTransactionWithResult(): String {
        return transactionTemplate.execute(TransactionCallback { status ->
            println("Executing in transaction with result")
            "Transaction Result"
        }) ?: "Default Result"
    }
}

import org.springframework.transaction.support.TransactionSynchronizationManager


class MyService {

    fun someMethod() {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            // The current transaction is active
        }
    }
    
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-webflux'
    implementation 'org.springframework.boot:spring-boot-starter-data-r2dbc'
    implementation 'io.r2dbc:r2dbc-postgresql'
}

spring:
  r2dbc:
    url: r2dbc:postgresql://localhost:5432/mydatabase
    username: myuser
    password: mypassword

import org.springframework.data.annotation.Id
import org.springframework.data.relational.core.mapping.Table


@Table("users")
data class User(
    @Id val id: Long? = null,
    val name: String,
    val email: String
)

import org.springframework.data.repository.reactive.ReactiveCrudRepository
import reactor.core.publisher.Mono


interface UserRepository : ReactiveCrudRepository<User, Long> {
  
    fun findByEmail(email: String): Mono<User>
    
}

import org.springframework.stereotype.Service
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono


@Service
class UserService(private val userRepository: UserRepository) {
    fun getAllUsers(): Flux<User> = userRepository.findAll()

    fun getUserById(id: Long): Mono<User> = userRepository.findById(id)

    fun createUser(user: User): Mono<User> = userRepository.save(user)

    fun updateUser(id: Long, user: User): Mono<User> = userRepository.findById(id)
            .flatMap {
                val updatedUser = it.copy(name = user.name, email = user.email)
                userRepository.save(updatedUser)
            }

    fun deleteUser(id: Long): Mono<Void> = userRepository.deleteById(id)
}

import org.springframework.web.bind.annotation.*
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono


@RestController
@RequestMapping("/users")
class UserController(private val userService: UserService) {

    @GetMapping
    fun getAllUsers(): Flux<User> = userService.getAllUsers()

    @GetMapping("/{id}")
    fun getUserById(@PathVariable id: Long): Mono<User> = userService.getUserById(id)

    @PostMapping
    fun createUser(@RequestBody user: User): Mono<User> = userService.createUser(user)

    @PutMapping("/{id}")
    fun updateUser(@PathVariable id: Long, @RequestBody user: User): Mono<User> = userService.updateUser(id, user)

    @DeleteMapping("/{id}")
    fun deleteUser(@PathVariable id: Long): Mono<Void> = userService.deleteUser(id)
    
}

dependencies {
    implementation 'org.flywaydb:flyway-core'
}

logging:
  level:
    org.springframework.data.r2dbc: DEBUG
spring:
  r2dbc:
    url: r2dbc:postgresql://localhost:5432/database
    username: user
    password: 123
  flyway:
    url: jdbc:postgresql://localhost:5432/database
    user: user
    password: 123
    locations: classpath:db/migration
jwt:
  secret: very-very-secret-key-should-be-almost-infinity
  expiration: 86400

logging:
  level:
    org.springframework.data.r2dbc: DEBUG

spring:
  r2dbc:
    url: r2dbc:postgresql://localhost:5432/database
    username: user
    password: 123

flyway:
    url: jdbc:postgresql://localhost:5432/database
    user: user
    password: 123
    locations: classpath:db/migration

jwt:
  secret: very-very-secret-key-should-be-almost-infinity
  expiration: 86400

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE
);

@Value("\${my.secret.key}")
private lateinit var mySecretKey: String

spring:
  cloud:
    vault:
      uri: http://127.0.0.1:8200
      token: s.xxxxxxxx
      kv:
        enabled: true
        backend: secret
        default-context: application

import java.io.FileInputStream
import java.security.KeyStore


val keyStore = KeyStore.getInstance("JKS")
val fis = FileInputStream("keystore.jks")
keyStore.load(fis, "keystore-password".toCharArray())
val privateKey = keyStore.getKey("alias", "key-password".toCharArray()) as PrivateKey

import com.amazonaws.services.secretsmanager.AWSSecretsManager
import com.amazonaws.services.secretsmanager.model.GetSecretValueRequest


@Autowired
private lateinit var awsSecretsManager: AWSSecretsManager

fun getSecret(): String {
    val getSecretValueRequest = GetSecretValueRequest().withSecretId("mySecretId")
    val getSecretValueResult = awsSecretsManager.getSecretValue(getSecretValueRequest)
    return getSecretValueResult.secretString
}

import org.jasypt.encryption.pbe.PooledPBEStringEncryptor
import org.jasypt.encryption.pbe.config.SimpleStringPBEConfig
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration


@Configuration
class JasyptConfig {

    @Bean
    fun stringEncryptor(): PooledPBEStringEncryptor {
        val encryptor = PooledPBEStringEncryptor()
        val config = SimpleStringPBEConfig().apply {
            password = "encryption-password"
            algorithm = "PBEWithMD5AndDES"
        }
        encryptor.setConfig(config)
        return encryptor
    }
    
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-cache'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.jetbrains.kotlin:kotlin-reflect'
    implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-reactor:1.6.1'
    runtimeOnly 'com.h2database:h2'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

import org.springframework.cache.annotation.EnableCaching
import org.springframework.context.annotation.Configuration


@Configuration
@EnableCaching
class CacheConfig

@Service
class UserService {

    @Cacheable("users", key = "#id")
    fun getUserById(id: Long): User {
        // Simulating a long query
        Thread.sleep(3000)
        return User(id, "User$id")
    }

    @CachePut(value = ["users"], key = "#user.id")
    fun updateUser(user: User): User {
        // User update logic
        return user
    }

    @CacheEvict(value = ["users"], key = "#id")
    fun deleteUser(id: Long) {
        // Logic for deleting a user
    }

    @Caching(
        put = [CachePut(value = ["users"], key = "#user.id")],
        evict = [CacheEvict(value = ["users_list"], allEntries = true)]
    )
    fun saveUser(user: User): User {
        // Logic for saving user
        return user
    }
}

spring:
  cache:
    type: simple

spring:
  cache:
    type: jcache

spring:
  cache:
    type: ehcache

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd">
    <cache name="users" maxEntriesLocalHeap="1000" timeToLiveSeconds="3600"/>
</ehcache>

spring:
  cache:
    type: hazelcast

<hazelcast xmlns="http://www.hazelcast.com/schema/config"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.hazelcast.com/schema/config
           http://www.hazelcast.com/schema/config/hazelcast-config-3.10.xsd">
    <map name="users">
        <time-to-live-seconds>3600</time-to-live-seconds>
    </map>
</hazelcast>

spring:
  cache:
    type: infinispan

<infinispan>
    <cache-container>
        <local-cache name="users">
            <expiration lifespan="3600000"/>
        </local-cache>
    </cache-container>
</infinispan>

spring:
  cache:
    type: caffeine

import com.github.benmanes.caffeine.cache.Caffeine
import org.springframework.cache.CacheManager
import org.springframework.cache.caffeine.CaffeineCacheManager
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.util.concurrent.TimeUnit


@Configuration
class CacheConfig {
    
    @Bean
    fun cacheManager(): CacheManager {
        val cacheManager = CaffeineCacheManager("users")
        cacheManager.setCaffeine(
            Caffeine.newBuilder()
                .expireAfterWrite(60, TimeUnit.MINUTES)
                .maximumSize(100)
        )
        return cacheManager
    }
    
}

spring:
  cache:
    type: redis
  redis:
    host: localhost
    port: 6379

import org.springframework.cache.annotation.EnableCaching
import org.springframework.cache.redis.RedisCacheConfiguration
import org.springframework.cache.redis.RedisCacheManager
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.connection.RedisConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.serializer.RedisSerializationContext
import org.springframework.data.redis.serializer.StringRedisSerializer

@Configuration
@EnableCaching
class CacheConfig {

    @Bean
    fun redisCacheManager(redisConnectionFactory: RedisConnectionFactory): RedisCacheManager {
        val config = RedisCacheConfiguration.defaultCacheConfig()
            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(StringRedisSerializer()))

        return RedisCacheManager.builder(redisConnectionFactory)
            .cacheDefaults(config)
            .build()
    }

    @Bean
    fun redisTemplate(redisConnectionFactory: RedisConnectionFactory): RedisTemplate<String, Any> {
        val template = RedisTemplate<String, Any>()
        template.setConnectionFactory(redisConnectionFactory)
        template.keySerializer = StringRedisSerializer()
        template.valueSerializer = StringRedisSerializer()
        return template
    }
}

spring:
  cache:
    type: guava

import com.google.common.cache.CacheBuilder
import org.springframework.cache.CacheManager
import org.springframework.cache.guava.GuavaCacheManager
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.util.concurrent.TimeUnit

@Configuration
class CacheConfig {

    @Bean
    fun cacheManager(): CacheManager {
        val cacheManager = GuavaCacheManager("users")
        cacheManager.setCacheBuilder(
            CacheBuilder.newBuilder()
                .expireAfterWrite(60, TimeUnit.MINUTES)
                .maximumSize(100)
        )
        return cacheManager
    }
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("software.amazon.awssdk:s3")
    implementation("software.amazon.awssdk:auth")
}

aws.accessKeyId=YOUR_ACCESS_KEY_ID
aws.secretKey=YOUR_SECRET_KEY
aws.region=us-east-1
aws.s3.bucketName=your-bucket-name

import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider
import software.amazon.awssdk.regions.Region
import software.amazon.awssdk.services.s3.S3Client


@Configuration
class AwsS3Config {
  
    @Value("\${aws.accessKeyId}")
    lateinit var accessKeyId: String
  
    @Value("\${aws.secretKey}")
    lateinit var secretKey: String
  
    @Value("\${aws.region}")
    lateinit var region: String
  
    @Bean
    fun s3Client(): S3Client {
        val credentials = AwsBasicCredentials.create(accessKeyId, secretKey)
        return S3Client.builder()
            .region(Region.of(region))
            .credentialsProvider(StaticCredentialsProvider.create(credentials))
            .build()
    }
    
}

import org.springframework.beans.factory.annotation.Value
import org.springframework.stereotype.Service
import org.springframework.web.multipart.MultipartFile
import software.amazon.awssdk.services.s3.S3Client
import software.amazon.awssdk.services.s3.model.PutObjectRequest
import software.amazon.awssdk.services.s3.model.GetObjectRequest
import java.nio.file.Paths


@Service
class S3Service(private val s3Client: S3Client) {
  
    @Value("\${aws.s3.bucketName}")
    lateinit var bucketName: String
  
    fun uploadFile(file: MultipartFile): String {
        val fileName = file.originalFilename ?: throw IllegalArgumentException("File name is missing")
        val putObjectRequest = PutObjectRequest.builder()
            .bucket(bucketName)
            .key(fileName)
            .build()       
        s3Client.putObject(putObjectRequest, Paths.get(fileName))
        return "File uploaded successfully: $fileName"
    }
    
    fun downloadFile(fileName: String): ByteArray {
        val getObjectRequest = GetObjectRequest.builder()
            .bucket(bucketName)
            .key(fileName)
            .build()
        return s3Client.getObject(getObjectRequest).readAllBytes()
    }
    
}

import org.springframework.http.HttpHeaders
import org.springframework.http.MediaType
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.*
import org.springframework.web.multipart.MultipartFile


@RestController
@RequestMapping("/s3")
class S3Controller(private val s3Service: S3Service) {
  
    @PostMapping("/upload")
    fun uploadFile(@RequestParam("file") file: MultipartFile): String {
        return s3Service.uploadFile(file)
    }
    
    @GetMapping("/download/{fileName}")
    fun downloadFile(@PathVariable fileName: String): ResponseEntity<ByteArray> {
        val fileBytes = s3Service.downloadFile(fileName)
        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"$fileName\"")
            .contentType(MediaType.APPLICATION_OCTET_STREAM)
            .body(fileBytes)
    }
    
}

name: CI
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2
    - name: Set up JDK 11
      uses: actions/setup-java@v2
      with:
        distribution: 'adopt'
        java-version: '11'
    - name: Cache Gradle packages
      uses: actions/cache@v2
      with:
        path: ~/.gradle/caches
        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
        restore-keys: |
          ${{ runner.os }}-gradle-
    - name: Grant execute permission for gradlew
      run: chmod +x gradlew
    - name: Build with Gradle
      run: ./gradlew build
    - name: Run tests
      run: ./gradlew test