bg_image
header

Entity Manager

💡 What is an Entity Manager?

An Entity Manager is a core component of ORM (Object-Relational Mapping) frameworks, especially in Java (JPA – Java Persistence API), but also in other languages like PHP (Doctrine ORM).


📦 Responsibilities of an Entity Manager:

  1. Persisting:

  2. Finding/Loading:

    • Retrieves an object by its ID or other criteria.

    • Example: $entityManager->find(User::class, 1);

  3. Updating:

    • Tracks changes to objects and writes them to the database (usually via flush()).

  4. Removing:

    • Deletes an object from the database.

    • Example: $entityManager->remove($user);

  5. Managing Transactions:

    • Begins, commits, or rolls back transactions.

  6. Handling Queries:


🔁 Entity Lifecycle:

The Entity Manager tracks the state of entities:

  • managed (being tracked),

  • detached (no longer tracked),

  • removed (marked for deletion),

  • new (not yet persisted).


🛠 Example with Doctrine (PHP):

$user = new User();
$user->setName('Max Mustermann');

$entityManager->persist($user); // Mark for saving
$entityManager->flush();        // Write to DB

✅ Summary:

The Entity Manager is the central component for working with database objects — creating, reading, updating, deleting. It abstracts SQL and provides a clean, object-oriented way to interact with your data layer.


Aspect Oriented Programming - AOP

Aspect-Oriented Programming (AOP) is a programming paradigm focused on modularizing cross-cutting concerns—aspects of a program that affect multiple parts of the codebase and don't fit neatly into object-oriented or functional structures.


💡 Goal:

Typical cross-cutting concerns include logging, security checks, error handling, transaction management, or performance monitoring. These concerns often appear in many classes and methods. AOP allows you to write such logic once and have it automatically applied where needed.


🔧 Key Concepts:

  • Aspect: A module that encapsulates a cross-cutting concern.

  • Advice: The actual code to be executed (e.g., before, after, or around a method call).

  • Join Point: A point in the program flow where an aspect can be applied (e.g., method execution).

  • Pointcut: A rule that defines which join points are affected (e.g., "all methods in class X").

  • Weaving: The process of combining aspects with the main program code—at compile-time, load-time, or runtime.


🛠 Example (Java with Spring AOP):

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBeforeMethod(JoinPoint joinPoint) {
        System.out.println("Calling method: " + joinPoint.getSignature().getName());
    }
}

This code automatically logs a message before any method in the com.example.service package is executed.


✅ Benefits:

  • Improved modularity

  • Reduced code duplication

  • Clear separation of business logic and system-level concerns


❌ Drawbacks:

  • Can reduce readability (the flow isn't always obvious)

  • Debugging can become more complex

  • Often depends on specific frameworks (e.g., Spring, AspectJ)


Salesforce Apex

Salesforce Apex is an object-oriented programming language specifically designed for the Salesforce platform. It is similar to Java and is primarily used to implement custom business logic, automation, and integrations within Salesforce.

Key Features of Apex:

  • Cloud-based: Runs exclusively on Salesforce servers.

  • Java-like Syntax: If you know Java, you can learn Apex quickly.

  • Tightly Integrated with Salesforce Database (SOQL & SOSL): Enables direct data queries and manipulations.

  • Event-driven: Often executed through Salesforce triggers (e.g., record changes).

  • Governor Limits: Salesforce imposes limits (e.g., maximum SOQL queries per transaction) to maintain platform performance.

Uses of Apex:

  • Triggers: Automate actions when records change.

  • Batch Processing: Handle large data sets in background jobs.

  • Web Services & API Integrations: Communicate with external systems.

  • Custom Controllers for Visualforce & Lightning: Control user interfaces.

 


Controller

A Controller is a key component in the Model-View-Controller (MVC) architecture. It acts as an intermediary between the user interface (View) and the business logic or data (Model).

Functions of a Controller

  1. Handling User Input

    • The controller receives requests (e.g., from a web form or an API call).
  2. Processing the Request

    • It analyzes the input and decides which action to take.
    • If necessary, it validates the data.
  3. Interacting with the Model

    • The controller forwards the request to the model to fetch, update, or store data.
  4. Updating the View

    • Once the model processes the request, the controller passes the data to the view.
    • The view is then updated with the new information.

Example: Blog System

Suppose a user wants to create a new blog post:

  1. The user fills out a form and clicks "Save" (input to the controller).
  2. The controller receives the request, validates the input, and sends it to the model.
  3. The model stores the post in the database.
  4. The controller retrieves the updated list of posts and sends it to the view.
  5. The view displays the new blog post.

Example Code in PHP (Laravel)

class BlogController extends Controller {
    public function store(Request $request) {
        // Validierung der Benutzereingabe
        $request->validate([
            'title' => 'required|max:255',
            'content' => 'required',
        ]);

        // Neues Blog-Post-Model erstellen und speichern
        BlogPost::create([
            'title' => $request->input('title'),
            'content' => $request->input('content'),
        ]);

        // Weiterleitung zur Blog-Übersicht
        return redirect()->route('blog.index')->with('success', 'Post erstellt!');
    }
}

Conclusion

✔ A controller manages the flow of an application and separates business logic from presentation.
✔ It ensures clean code structure, as each component (Model, View, Controller) has a specific responsibility.
✔ Modern frameworks like Laravel, Django, or ASP.NET often include built-in routing mechanisms that automatically direct requests to the appropriate controllers.

 


Catalyst Web Framework

The Catalyst Framework is a flexible and powerful web framework for Perl. It enables the development of scalable and maintainable web applications and follows the Model-View-Controller (MVC) design pattern.

Key Features of Catalyst

MVC Architecture – Clear separation of business logic, presentation, and data management
Flexibility – Supports various templating systems and ORM solutions like DBIx::Class
Extensibility – Many plugins and modules available
Asynchronous Capabilities – Can be integrated with event-driven architectures
REST APIs & WebSockets – Support for modern web technologies

Use Cases

 


Objektorientiertes Datenbanksystem - OODBMS

An object-oriented database management system (OODBMS) is a type of database system that combines the principles of object-oriented programming (OOP) with the functionality of a database. It allows data to be stored, retrieved, and managed as objects, similar to how they are defined in object-oriented programming languages like Java, Python, or C++.

Key Features of an OODBMS:

  1. Object Model:

    • Data is stored as objects, akin to objects in OOP.
    • Each object has attributes (data) and methods (functions that operate on the data).
  2. Classes and Inheritance:

    • Objects are defined based on classes.
    • Inheritance allows new classes to be derived from existing ones, promoting code and data reuse.
  3. Encapsulation:

    • Data and associated operations (methods) are bundled together in the object.
    • This enhances data integrity and reduces inconsistencies.
  4. Persistence:

    • Objects, which normally exist only in memory, can be stored permanently in an OODBMS, ensuring they remain available even after the program ends.
  5. Object Identity (OID):

    • Each object has a unique identifier, independent of its attribute values. This distinguishes it from relational databases, where identity is often defined by primary keys.
  6. Complex Data Types:

    • OODBMS supports complex data structures, such as nested objects or arrays, without needing to convert them into flat tables.

Advantages of an OODBMS:

  • Seamless OOP Integration: Developers can use the same structures as in their programming language without needing to convert data into relational tables.
  • Support for Complex Data: Ideal for applications with complex data, such as CAD systems, multimedia applications, or scientific data.
  • Improved Performance: Reduces the need for conversion between program objects and database tables.

Disadvantages of an OODBMS:

  • Limited Adoption: OODBMS is less widely used compared to relational database systems (RDBMS) like MySQL or PostgreSQL.
  • Lack of Standardization: There are fewer standardized query languages (like SQL in RDBMS).
  • Steeper Learning Curve: Developers need to understand object-oriented principles and the specific OODBMS implementation.

Examples of OODBMS:

  • ObjectDB (optimized for Java developers)
  • Versant Object Database
  • db4o (open-source, for Java and .NET)
  • GemStone/S

Object-oriented databases are particularly useful for managing complex, hierarchical, or nested data structures commonly found in modern software applications.

 


Document Object Model - DOM

The Document Object Model (DOM) is a standardized interface provided by web browsers to represent and programmatically manipulate structured documents, especially HTML and XML documents. It describes the hierarchical structure of a document as a tree, where each node represents an element, attribute, or text.

Key Features of the DOM:

  1. Tree Structure:

    • An HTML document is represented as a hierarchical tree. The root is the <html> element, with child nodes such as <head>, <body>, <div>, <p>, etc.
  2. Object-Oriented Representation:

    • Each element in the document is represented as an object that can be accessed and modified through methods and properties.
  3. Interactivity:

    • The DOM allows developers to modify content and styles of a webpage at runtime. For instance, JavaScript scripts can change the text of a <p> element or insert a new <div>.
  4. Platform and Language Agnostic:

    • Although commonly used with JavaScript, the DOM can also be manipulated using other languages like Python, Java, or PHP.

Examples of DOM Manipulation:

1. Accessing an Element:

let element = document.getElementById("myElement");

2. Changing Content:

element.textContent = "New Text";

3. Adding a New Element:

let newNode = document.createElement("div");
document.body.appendChild(newNode);

Important Note:

The DOM is defined and maintained by the W3C (World Wide Web Consortium) standards and is constantly updated to support modern web technologies.

 

 

 


PSR-11

PSR-11 is a PHP Standard Recommendation (PHP Standard Recommendation) that defines a Container Interface for dependency injection. It establishes a standard way to interact with dependency injection containers in PHP projects.

Purpose of PSR-11

PSR-11 was introduced to ensure interoperability between different frameworks, libraries, and tools that use dependency injection containers. By adhering to this standard, developers can switch or integrate various containers without modifying their code.

Core Components of PSR-11

PSR-11 specifies two main interfaces:

  1. ContainerInterface
    This is the central interface providing methods to retrieve and check services in the container.

namespace Psr\Container;

interface ContainerInterface {
    public function get(string $id);
    public function has(string $id): bool;
}
    • get(string $id): Returns the instance (or service) registered in the container under the specified ID.
    • has(string $id): Checks whether the container has a service registered with the given ID.
  • 2. NotFoundExceptionInterface
    This is thrown when a requested service is not found in the container.

namespace Psr\Container;

interface NotFoundExceptionInterface extends ContainerExceptionInterface {
}

3. ContainerExceptionInterface
A base exception for any general errors related to the container.

Benefits of PSR-11

  • Interoperability: Enables various frameworks and libraries to use the same container.
  • Standardization: Provides a consistent API for accessing containers.
  • Extensibility: Allows developers to create their own containers that comply with PSR-11.

Typical Use Cases

PSR-11 is widely used in frameworks like Symfony, Laravel, and Zend Framework (now Laminas), which provide dependency injection containers. Libraries like PHP-DI or Pimple also support PSR-11.

Example

Here’s a basic example of using PSR-11:

use Psr\Container\ContainerInterface;

class MyService {
    public function __construct(private string $message) {}
    public function greet(): string {
        return $this->message;
    }
}

$container = new SomePSR11CompliantContainer();
$container->set('greeting_service', function() {
    return new MyService('Hello, PSR-11!');
});

if ($container->has('greeting_service')) {
    $service = $container->get('greeting_service');
    echo $service->greet(); // Output: Hello, PSR-11!
}

Conclusion

PSR-11 is an essential interface for modern PHP development, as it standardizes dependency management and resolution. It promotes flexibility and maintainability in application development.

 

 

 


PSR-7

PSR-7 is a PHP Standard Recommendation (PSR) that focuses on HTTP messages in PHP. It was developed by the PHP-FIG (Framework Interoperability Group) and defines interfaces for working with HTTP messages, as used by web servers and clients.

Key Features of PSR-7:

  1. Request and Response:
    PSR-7 standardizes how HTTP requests and responses are represented in PHP. It provides interfaces for:

    • RequestInterface: Represents HTTP requests.
    • ResponseInterface: Represents HTTP responses.
  2. Immutability:
    All objects are immutable, meaning that any modification to an HTTP object creates a new object rather than altering the existing one. This improves predictability and makes debugging easier.

  3. Streams:
    PSR-7 uses stream objects to handle HTTP message bodies. The StreamInterface defines methods for interacting with streams (e.g., read(), write(), seek()).

  4. ServerRequest:
    The ServerRequestInterface extends the RequestInterface to handle additional data such as cookies, server parameters, and uploaded files.

  5. Middleware Compatibility:
    PSR-7 serves as the foundation for middleware architectures in PHP. It simplifies the creation of middleware components that process HTTP requests and manipulate responses.

Usage:

PSR-7 is widely used in modern PHP frameworks and libraries, including:

Purpose:

The goal of PSR-7 is to improve interoperability between different PHP libraries and frameworks by defining a common standard for HTTP messages.

 


PSR-2

PSR-2 is a coding style guideline for PHP developed by the PHP-FIG (Framework Interop Group) to make code more readable and consistent, allowing development teams to collaborate more easily. The abbreviation “PSR” stands for “PHP Standards Recommendation”.

Key Points in PSR-2:

  1. Indentation: Use four spaces for indentation instead of tabs.
  2. Line Length: Code should ideally not exceed 80 characters per line, with an absolute maximum of 120 characters.
  3. File Structure: Each PHP file should either contain only classes, functions, or executable code, but not a mix.
  4. Braces: Opening braces { for classes and methods should be on the next line, whereas braces for control structures (like if, for) should be on the same line.
  5. Spaces: Place a space between control keywords and parentheses, as well as around operators (e.g., =, +).

Example

Here’s a simple example following these guidelines:

<?php

namespace Vendor\Package;

class ExampleClass
{
    public function exampleMethod($arg1, $arg2 = null)
    {
        if ($arg1 === $arg2) {
            throw new \Exception('Arguments cannot be equal');
        }

        return $arg1;
    }
}

PSR-2 has since been expanded and replaced by PSR-12, which includes additional rules to further improve code consistency.