Este documento detalla la implementación de un sistema de gestión de documentos oficiales (OA) desarrollado con Java Spring Boot. El sistema está diseñado para facilitar la administración y el flujo de documentos dentro de una organización.

El sistema se basa en un stack tecnológico robusto, combinando un framework backend potente con una interfaz de usuario moderna y reactiva.

Backend: Spring Boot

Spring Boot es un framework de Java que simplifica la creación de aplicaciones Spring independientes y listas para producción. Su filosofía de "configuración sobre convención" reduce la necesidad de configuraciones XML extensas, permitiendo a los desarrolladores centrarse en la lógica de negocio. Spring Boot incluye servidores web embebidos como Tomcat, lo que facilita la creación de ejecutables JAR y simplifica enormemente el despliegue y la ejecución de aplicaciones. Además, ofrece un rico soporte para monitoreo y gestión a través de Spring Boot Actuator, y una amplia gama de starters que facilitan la integración de diversas funcionalidades como seguridad, acceso a datos, colas de mensajes y caché.

Frontend: Vue.js

Vue.js es un framwork progresivo de JavaScript para construir interfaces de usuario y aplicaciones de página única (SPA). Se destaca por su sistema de enlace de datos reactivo, que facilita la sincronización entre la vista y el estado de la aplicación. Su enfoque en componentes permite modularizar la interfaz en piezas reutilizables e independientes, mejorando la mantenibilidad y la escalabilidad del código. La documentación completa, la comunidad activa y la variedad de herramientas y plugins disponibles hacen de Vue.js una opción atractiva para el desarrollo frontend moderno.

A continuación, se presentan fragmentos de código clave que ilustran la estructura y funcionalidad del sistema.

Clase Principle de la Aplicación

package com;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
@MapperScan(basePackages = {"com.dao"})
public class DocumentManagerApplication extends SpringBootServletInitializer {

   public static void main(String[] args) {
       SpringApplication.run(DocumentManagerApplication.class, args);
   }

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder applicationBuilder) {
       return applicationBuilder.sources(DocumentManagerApplication.class);
   }
}
       

Controlador de Usuarios (Ejemplo)

Este controlador maneja operaciones relacionadas con la gestión de usuarios, incluyendo autenticación, registro y consultas.

package com.controller;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;
import com.entity.UserEntity;
import com.entity.view.UserView;
import com.service.TokenService;
import com.service.UserService;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
* Gestiona las operaciones de usuarios.
*/
@RestController
@RequestMapping("/user")
public class UserController {
   @Autowired
   private UserService userService;

   @Autowired
   private TokenService tokenService;

   /**
    * Autenticación de usuario.
    */
   @IgnoreAuth
   @RequestMapping(value = "/login")
   public R login(String username, String password, HttpServletRequest request) {
       UserEntity user = userService.selectOne(new EntityWrapper<userentity>().eq("username", username));
       if (user == null || !user.getPassword().equals(password)) {
           return R.error("Usuario o contraseña incorrectos");
       }

       String token = tokenService.generateToken(user.getId(), username, "user", "Usuario");
       return R.ok().put("token", token);
   }

   /**
    * Registro de nuevo usuario.
    */
   @IgnoreAuth
   @RequestMapping("/register")
   public R register(@RequestBody UserEntity user) {
       UserEntity existingUser = userService.selectOne(new EntityWrapper<userentity>().eq("username", user.getUsername()));
       if (existingUser != null) {
           return R.error("El nombre de usuario ya existe");
       }
       long userId = System.currentTimeMillis();
       user.setId(userId);
       userService.insert(user);
       return R.ok();
   }

   /**
    * Obtiene información del usuario actual en sesión.
    */
   @RequestMapping("/session")
   public R getCurrentUser(HttpServletRequest request) {
       Long userId = (Long) request.getSession().getAttribute("userId");
       UserEntity user = userService.selectById(userId);
       return R.ok().put("data", user);
   }

   /**
    * Listado de usuarios para administración.
    */
   @RequestMapping("/page")
   public R adminPage(@RequestParam Map<string object=""> params, UserEntity user) {
       EntityWrapper<userentity> ew = new EntityWrapper<>();
       PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, user), params), params));
       return R.ok().put("data", page);
   }

   /**
    * Listado de usuarios para frontend.
    */
   @IgnoreAuth
   @RequestMapping("/list")
   public R frontendList(@RequestParam Map<string object=""> params, UserEntity user) {
       EntityWrapper<userentity> ew = new EntityWrapper<>();
       PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, user), params), params));
       return R.ok().put("data", page);
   }

   /**
    * Consulta de detalles de un usuario.
    */
   @RequestMapping("/query")
   public R query(UserEntity user) {
       EntityWrapper<userentity> ew = new EntityWrapper<>();
       ew.allEq(MPUtil.allEQMapPre(user, "user"));
       UserView userView = userService.selectView(ew);
       return R.ok("Consulta de usuario exitosa").put("data", userView);
   }

   /**
    * Obtiene detalles de un usuario por ID (admin).
    */
   @RequestMapping("/info/{id}")
   public R info(@PathVariable("id") Long id) {
       UserEntity user = userService.selectById(id);
       return R.ok().put("data", user);
   }

   /**
    * Guarda un nuevo usuario (admin).
    */
   @RequestMapping("/save")
   public R save(@RequestBody UserEntity user) {
       if (userService.selectCount(new EntityWrapper<userentity>().eq("username", user.getUsername())) > 0) {
           return R.error("El nombre de usuario ya existe");
       }
       long userId = System.currentTimeMillis();
       user.setId(userId);
       userService.insert(user);
       return R.ok();
   }

   /**
    * Actualiza un usuario existente.
    */
   @RequestMapping("/update")
   @Transactional
   public R update(@RequestBody UserEntity user) {
       if (userService.selectCount(new EntityWrapper<userentity>().ne("id", user.getId()).eq("username", user.getUsername())) > 0) {
           return R.error("El nombre de usuario ya existe");
       }
       userService.updateById(user);
       return R.ok();
   }

   /**
    * Elimina usuarios por IDs.
    */
   @RequestMapping("/delete")
   public R delete(@RequestBody Long[] ids) {
       userService.deleteBatchIds(Arrays.asList(ids));
       return R.ok();
   }
}
       </userentity></userentity></userentity></userentity></string></userentity></string></userentity></userentity>

Las pruebas exhaustivas son fundamentales para asegurar la calidad y fiabilidad del sistema. Se emplean diversas metodologías para identificar y corregir posibles defectos.

Objetivos de las Pruebas

El objetivo principal de las pruebas del sistema es validar que la aplicación cumple con los requisitos especificados, garantizando una experiencia de usuario fluida y sin problemas. Se busca anticipar y resolver cualquier inconveniente que los usuarios puedan encontrar, asegurando la robustez y la lógica coherente de todas las funcionalidades.

Pruebas Funcionales

Se realizan pruebas de caja negra en los módulos funcionales del sistema. Esto incluye la validación de entardas, casos límite, campos obligatorios y opcionales. Se desarrollan casos de prueba específicos para verificar la correcta ejecución de cada función. Por ejemplo, la prueba de la funcionalidad de inicio de sesión valida que el sistema responda adecuadamente a credenciales correctas e incorrectas, y que se apliquen las validaciones de roles si es necesario.

Conclusión de las Pruebas

Tras una serie de pruebas rigurosas, se concluye que el sistema implementado satisface los requisitos de diseño tanto funcionales como de rendimiento. La arquitectura y la lógica subyacente han sido validadas, demostrando su adecuación para la gestión de documentos oficiales y asegurando una experiencia de usuario positiva y eficiente.

Para obtener el código fuente completo, base de datos y documentación adicional, por favor contacte al autor a través de la información proporcionada en la sección de contacto.