El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

Introducció

Les capes d'una arquitectura de sistemes són una manera d'organitzar i estructurar els components d'un sistema per millorar la seva mantenibilitat, escalabilitat i comprensibilitat. Aquest enfocament divideix el sistema en diferents nivells, cadascun amb responsabilitats específiques, permetent una millor gestió i desenvolupament del sistema.

Objectius d'Aprenentatge

En aquesta secció, aprendràs:

Què són les capes d'una arquitectura.
Els diferents tipus de capes i les seves funcions.
Els avantatges d'utilitzar una arquitectura en capes.
Com implementar una arquitectura en capes amb exemples pràctics.

Conceptes Clau

Què són les capes d'una arquitectura?

Les capes d'una arquitectura són divisions lògiques d'un sistema que separen les diferents responsabilitats i funcions en nivells independents. Cada capa té un rol específic i interactua amb altres capes de manera controlada.

Tipus de capes

Una arquitectura en capes típicament inclou les següents capes:

Capa de Presentació (UI)
Capa de Lògica de Negoci
Capa de Persistència de Dades
Capa de Serveis
Capa d'Infraestructura

1. Capa de Presentació (UI)

Funció: Gestiona la interfície d'usuari i la interacció amb l'usuari final.
Responsabilitats:
- Renderitzar la informació a l'usuari.
- Capturar les accions de l'usuari i enviar-les a la capa de lògica de negoci.
Exemples: HTML, CSS, JavaScript, frameworks com Angular, React.

2. Capa de Lògica de Negoci

Funció: Conté les regles de negoci i la lògica que defineixen com es processen les dades.
Responsabilitats:
- Processar les dades rebudes de la capa de presentació.
- Aplicar les regles de negoci.
- Enviar les dades processades a la capa de persistència o de presentació.
Exemples: Classes de serveis en Java, .NET, Python.

3. Capa de Persistència de Dades

Funció: Gestiona l'emmagatzematge i recuperació de dades.
Responsabilitats:
- Interactuar amb la base de dades.
- Realitzar operacions CRUD (Crear, Llegir, Actualitzar, Esborrar).
Exemples: SQL, ORM (Object-Relational Mapping) com Hibernate, Entity Framework.

4. Capa de Serveis

Funció: Proporciona serveis que poden ser utilitzats per altres capes o sistemes externs.
Responsabilitats:
- Exposar API's.
- Gestionar la comunicació entre diferents sistemes.
Exemples: RESTful APIs, SOAP, microserveis.

5. Capa d'Infraestructura

Funció: Proporciona serveis de suport necessaris per a les altres capes.
Responsabilitats:
- Gestió de la xarxa.
- Seguretat.
- Monitorització i logging.
Exemples: Serveis de núvol, servidors de bases de dades, sistemes de monitorització.

Avantatges d'una Arquitectura en Capes

Mantenibilitat: Cada capa pot ser desenvolupada, testejada i mantinguda de manera independent.
Escalabilitat: Les capes poden ser escalades de manera independent segons les necessitats.
Reutilització: Components de diferents capes poden ser reutilitzats en altres projectes.
Flexibilitat: Facilita la substitució o actualització de components sense afectar altres capes.

Exemples Pràctics

Exemple 1: Aplicació Web Simple

# Capa de Presentació (Flask)
from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/user', methods=['GET'])
def get_user():
    user_id = request.args.get('id')
    user = user_service.get_user(user_id)
    return jsonify(user)

# Capa de Lògica de Negoci
class UserService:
    def get_user(self, user_id):
        user = user_repository.get_user(user_id)
        return user

user_service = UserService()

# Capa de Persistència de Dades
class UserRepository:
    def get_user(self, user_id):
        # Simulació d'una consulta a la base de dades
        return {"id": user_id, "name": "John Doe"}

user_repository = UserRepository()

Exemple 2: Aplicació Empresarial amb Capes Completes

// Capa de Presentació (Spring MVC)
@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/user")
    public ResponseEntity<User> getUser(@RequestParam String id) {
        User user = userService.getUser(id);
        return new ResponseEntity<>(user, HttpStatus.OK);
    }
}

// Capa de Lògica de Negoci
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User getUser(String id) {
        return userRepository.findById(id).orElse(null);
    }
}

// Capa de Persistència de Dades
@Repository
public interface UserRepository extends JpaRepository<User, String> {
}

Exercicis Pràctics

Exercici 1: Crear una Aplicació en Capes

Descripció: Crea una aplicació web simple que permeti als usuaris registrar-se i iniciar sessió. Utilitza una arquitectura en capes per organitzar el codi.
Requisits:
- Capa de Presentació: Formulari de registre i inici de sessió.
- Capa de Lògica de Negoci: Validació de dades d'usuari.
- Capa de Persistència de Dades: Emmagatzematge d'usuaris en una base de dades.

Solució Proposada

# Capa de Presentació (Flask)
from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/register', methods=['POST'])
def register():
    data = request.get_json()
    result = user_service.register(data)
    return jsonify(result)

@app.route('/login', methods=['POST'])
def login():
    data = request.get_json()
    result = user_service.login(data)
    return jsonify(result)

# Capa de Lògica de Negoci
class UserService:
    def register(self, data):
        if not data.get('username') or not data.get('password'):
            return {"error": "Invalid data"}
        user = user_repository.create_user(data)
        return user

    def login(self, data):
        user = user_repository.find_user(data.get('username'))
        if user and user['password'] == data.get('password'):
            return {"message": "Login successful"}
        return {"error": "Invalid credentials"}

user_service = UserService()

# Capa de Persistència de Dades
class UserRepository:
    users = []

    def create_user(self, data):
        user = {"username": data.get('username'), "password": data.get('password')}
        self.users.append(user)
        return user

    def find_user(self, username):
        for user in self.users:
            if user['username'] == username:
                return user
        return None

user_repository = UserRepository()

Conclusió

En aquesta secció, hem après sobre les capes d'una arquitectura de sistemes, els diferents tipus de capes i les seves funcions, així com els avantatges d'utilitzar una arquitectura en capes. També hem vist exemples pràctics de com implementar una arquitectura en capes en diferents llenguatges de programació. Aquest coneixement és fonamental per dissenyar sistemes robustos, escalables i fàcils de mantenir.

Arquitectures de Sistemes: Principis i Pràctiques per Dissenyar Arquitectures Tecnològiques Robustes i Escalables

Capes d'una Arquitectura