1. Preparación del Entorno y Inicialización del Proyecto

Para comenzar, necesitamos configurar un entorno estable. Este entorno consta de tres partes: la red blockchain de FISCO BCOS, una herramienta gráfica para observar y operar en la blockchain (WeBASE-Front), y nuestro proyecto Spring Boot.

Primero, configuraremos una cadena de bloques de FISCO BCOS con cuatro nodos. Asegúrate de que tu entorno de desarrollo (Linux o MacOS, Windows a través de WSL o máquina virtual) tenga instaladas las herramientas básicas como openssl y curl. Luego, obtén el script de creación de la cadena desde el repositorio oficial:

# Crear y entrar en el directorio de trabajo
mkdir -p ~/fisco && cd ~/fisco
# Descargar el script de creación de la cadena
curl -#LO https://github.com/FISCO-BCOS/FISCO-BCOS/releases/download/v2.7.2/build_chain.sh
# Agregar permisos de ejecución
chmod u+x build_chain.sh

A continuación, usa el siguiente comando para crear una red blockchain de cuatro nodos:

# -l especifica las IP y puertos de los nodos, aquí se crean 4 nodos en 127.0.0.1
# -p especifica los puertos iniciales, 30300, 20200, 8545
./build_chain.sh -l "127.0.0.1:4" -p 30300,20200,8545

Una vez que el script se ejecute correctamente, se generará un directorio nodes en el directorio actual. Inicia todos los nodos:

# Entrar en el directorio de nodos e iniciarlos
cd ~/fisco/nodes/127.0.0.1 && ./start_all.sh

Verifica que los cuatro procesos de fisco-bcos estén en ejecución con el comando ps -ef | grep -v grep | grep fisco-bcos.

Para facilitar la interacción con la cadena, desplegaremos WeBASE-Front, una plataforma de gestión de blockchain. El despliegue más rápido es a través de Docker:

# Obtener la imagen más reciente
docker pull webasepro/webase-front:latest
# Ejecutar el contenedor, mapeando el puerto 5002 y montando el directorio de certificados SDK
docker run -d --name webase-front -p 5002:5002 -v ~/fisco/nodes/127.0.0.1/sdk:/data/sdk webasepro/webase-front

Accede a http://localhost:5002/WeBASE-Front con las credenciales por defecto admin/Abcd1234. En la página de "Gestión de Nodos" deberías ver los cuatro nodos que acabas de iniciar, lo que confirma que el frontend está conectado a la blockchain.

Ahora, pasemos a nuestro proyecto Java. Usa Spring Initializr (o crea directamente desde tu IDE) para inicializar un proyecto Spring Boot. Aquí hay algunas opciones clave:

• Versión de Spring Boot: 2.4.2.
• Empaquetado: Maven.
• Versión de Java: 11 (recomendada) o 8.
• Dependencias: Spring Web, Lombok, Spring Configuration Processor.

Configura el archivo pom.xml para incluir las dependencias necesarias, especialmente fisco-bcos-java-sdk:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.2</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>blockchain-student-mgr</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>blockchain-student-mgr</name>
    <properties>
        <java.version>11</java.version>
        <fisco-sdk.version>2.7.2</fisco-sdk.version>
        <hutool.version>5.8.16</hutool.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.fisco-bcos.java-sdk</groupId>
            <artifactId>fisco-bcos-java-sdk</artifactId>
            <version>${fisco-sdk.version}</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>${hutool.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Refresca el proyecto Maven. Ahora, estamos listos para diseñar y compilar los contratos inteligentes.

2. Diseño y Compilación de Contratos Inteligentes: Definición de Reglas de Datos en la Cadena

Los contratos inteligentes son el núcleo de la lógica de negocio de una apilcación blockchain. Para nuestro sistema de gestión de estudiantes, neecsitamos registrar ID y nombres de estudiantes, y implementar funcionalidades CRUD. Usaremos Solidity para escribir este contrato.

Crea un nuevo directorio src/main/solidity en la raíz del proyecto y dentro de él, crea el archivo StudentManager.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.4.25;

contract StudentManager {
    struct Student {
        uint256 id;
        string name;
        uint256 createdAt;
    }

    Student[] private students;
    uint256 private nextId = 1;
    mapping(uint256 => uint256) private idToIndex;

    event StudentAdded(uint256 indexed id, string name, uint256 createdAt);
    event StudentUpdated(uint256 indexed id, string newName);
    event StudentRemoved(uint256 indexed id);

    modifier studentExists(uint256 _id) {
        require(idToIndex[_id] != 0, "Student does not exist");
        _;
    }

    function addStudent(string memory _name) public returns (uint256) {
        students.push(Student(nextId, _name, block.timestamp));
        idToIndex[nextId] = students.length;
        emit StudentAdded(nextId, _name, block.timestamp);
        nextId++;
        return nextId - 1;
    }

    function updateStudent(uint256 _id, string memory _newName) public studentExists(_id) {
        students[idToIndex[_id]].name = _newName;
        emit StudentUpdated(_id, _newName);
    }

    function removeStudent(uint256 _id) public studentExists(_id) {
        delete students[idToIndex[_id]];
        delete idToIndex[_id];
        emit StudentRemoved(_id);
    }

    function getStudent(uint256 _id) public view studentExists(_id) returns (uint256, string memory, uint256) {
        Student memory s = students[idToIndex[_id]];
        return (s.id, s.name, s.createdAt);
    }
}

Este contrato define una estructura de datos para los estudiantes, permite agregar, acutalizar, eliminar y consultar estudiantes, y emite eventos para cada operación. A continuación, integraremos este contrato en nuestro backend de Spring Boot.