El backend del restaurante

@Service
public class PedidoService {

    private final PedidoRepository pedidos;
    private final PlatilloRepository platillos;
    private final CanalCocina canalCocina;       // hub WebSocket (3.3)
    private final ColaImpresion colaImpresion;   // impresión (3.4)
    // constructor…

    @Transactional
    public PedidoResponse crear(NuevoPedidoDTO dto, Long meseroId) {
        Pedido pedido = new Pedido(dto.mesaId(), dto.tipo(), meseroId);

        for (ItemPedidoDTO item : dto.items()) {
            // REGLA: el precio sale de la BD, jamás del cliente
            Platillo platillo = platillos.findById(item.platilloId())
                .orElseThrow(() -> new NegocioException(
                    "el platillo " + item.platilloId() + " no existe"));
            if (!platillo.isDisponible()) {
                throw new NegocioException(platillo.getNombre() + " está agotado");
            }
            pedido.agregarItem(platillo, item.cantidad(), item.notas());
        }

        Pedido guardado = pedidos.save(pedido);

        // efectos colaterales DESPUÉS de persistir:
        canalCocina.difundirPedidoNuevo(guardado);          // pantalla KDS
        colaImpresion.encolarComanda(guardado);             // impresora cocina

        return PedidoResponse.desde(guardado);              // entidad → DTO
    }
}

type PedidoService struct {
    repo       *PedidoRepo
    platillos  *PlatilloRepo
    hub        *ws.Hub            // hub WebSocket (3.3)
    impresion  *impresion.Cola    // impresión (3.4)
}

func (s *PedidoService) Crear(dto NuevoPedidoDTO, meseroID int64) (*Pedido, error) {
    pedido := NuevoPedido(dto.MesaID, dto.Tipo, meseroID)

    for _, item := range dto.Items {
        // REGLA: el precio sale de la BD, jamás del cliente
        platillo, err := s.platillos.PorID(item.PlatilloID)
        if err != nil {
            return nil, ErrNegocio{fmt.Sprintf(
                "el platillo %d no existe", item.PlatilloID)}
        }
        if !platillo.Disponible {
            return nil, ErrNegocio{platillo.Nombre + " está agotado"}
        }
        pedido.AgregarItem(platillo, item.Cantidad, item.Notas)
    }

    if err := s.repo.Guardar(pedido); err != nil {
        return nil, err
    }

    // efectos colaterales DESPUÉS de persistir:
    s.hub.Difundir("cocina", ws.Mensaje{
        Type: "PEDIDO_NUEVO", Datos: pedido})   // pantalla KDS
    s.impresion.EncolarComanda(pedido)          // impresora cocina

    return pedido, nil
}

Spring no te hace escribir el hub: su soporte de STOMP (un mini-protocolo de mensajería sobre WebSocket) trae suscripciones por "topic" ya resueltas. Los clientes usan la librería @stomp/stompjs en JS o stomp_dart_client en Flutter.

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // los clientes conectan a ws://servidor:8080/ws
        registry.addEndpoint("/ws").setAllowedOriginPatterns("*");
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");      // servidor → clientes
        registry.setApplicationDestinationPrefixes("/app"); // clientes → servidor
    }
}

@Component
public class CanalCocina {
    private final SimpMessagingTemplate plantilla;
    public CanalCocina(SimpMessagingTemplate plantilla) { this.plantilla = plantilla; }

    /** Lo llama PedidoService al crear un pedido. Llega a todo
        cliente suscrito a /topic/cocina. */
    public void difundirPedidoNuevo(Pedido pedido) {
        plantilla.convertAndSend("/topic/cocina",
            Map.of("type", "PEDIDO_NUEVO", "pedido", PedidoResponse.desde(pedido)));
    }
}

/* Y para mensajes que llegan DE los clientes (la ubicación del
   repartidor), un controller anotado: */
@Controller
public class UbicacionController {
    private final SimpMessagingTemplate plantilla;
    // constructor…

    @MessageMapping("/ubicacion")            // cliente publica a /app/ubicacion
    public void recibir(UbicacionDTO dto) {
        // reenviamos al mapa del escritorio:
        plantilla.convertAndSend("/topic/ubicaciones",
            Map.of("type", "UBICACION", "datos", dto));
    }
}

En Go el hub se escribe a mano con gorilla/websocket — son ~60 líneas y entenderlas te enseña exactamente qué hace STOMP por ti. El patrón canónico: un goroutine dueño del estado, y canales de Go para registrar, quitar y difundir (así no necesitas mutexes).

package ws

import "github.com/gorilla/websocket"

type Mensaje struct {
    Type  string `json:"type"`
    Datos any    `json:"datos,omitempty"`
    Canal string `json:"-"`      // no viaja: solo enruta internamente
}

type cliente struct {
    conn  *websocket.Conn
    canal string
    salida chan []byte          // buffer de envío por cliente
}

type Hub struct {
    clientes  map[*cliente]bool
    registrar chan *cliente
    quitar    chan *cliente
    difundir  chan Mensaje
}

func NuevoHub() *Hub {
    h := &Hub{
        clientes:  map[*cliente]bool{},
        registrar: make(chan *cliente),
        quitar:    make(chan *cliente),
        difundir:  make(chan Mensaje, 64),
    }
    go h.correr()
    return h
}

// correr es el ÚNICO goroutine que toca h.clientes → sin mutexes.
func (h *Hub) correr() {
    for {
        select {
        case c := <-h.registrar:
            h.clientes[c] = true
        case c := <-h.quitar:
            if h.clientes[c] {
                delete(h.clientes, c)
                close(c.salida)
            }
        case msg := <-h.difundir:
            datos, _ := json.Marshal(msg)
            for c := range h.clientes {
                if c.canal != msg.Canal {
                    continue
                }
                select {
                case c.salida <- datos:
                default:            // cliente lento: lo desconectamos
                    delete(h.clientes, c)
                    close(c.salida)
                }
            }
        }
    }
}

func (h *Hub) Difundir(canal string, msg Mensaje) {
    msg.Canal = canal
    h.difundir <- msg
}

var upgrader = websocket.Upgrader{
    // en la red local del restaurante aceptamos cualquier origen:
    CheckOrigin: func(r *http.Request) bool { return true },
}

func (h *Hub) Conectar(canal string) gin.HandlerFunc {
    return func(c *gin.Context) {
        // el token ya fue validado por el middleware (cap. 2.7)
        conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
        if err != nil {
            return
        }
        cl := &cliente{conn: conn, canal: canal, salida: make(chan []byte, 16)}
        h.registrar <- cl

        // goroutine de escritura: drena cl.salida hacia el socket
        go func() {
            for datos := range cl.salida {
                conn.WriteMessage(websocket.TextMessage, datos)
            }
            conn.Close()
        }()

        // goroutine de lectura: mensajes del cliente (p.ej. UBICACION)
        go func() {
            defer func() { h.quitar <- cl }()
            for {
                _, datos, err := conn.ReadMessage()
                if err != nil {
                    return              // cliente desconectado
                }
                var msg Mensaje
                if json.Unmarshal(datos, &msg) == nil && msg.Type == "UBICACION" {
                    // ubicación del repartidor → reenviar al mapa admin
                    h.Difundir("ubicaciones", msg)
                }
            }
        }()
    }
}

// registro de rutas en main.go:
//   hub := ws.NuevoHub()
//   r.GET("/ws/cocina",      auth.WsAuth("COCINA","ADMIN"), hub.Conectar("cocina"))
//   r.GET("/ws/ubicaciones", auth.WsAuth("REPARTIDOR","ADMIN"), hub.Conectar("ubicaciones"))
//   r.GET("/ws/notificaciones", auth.WsAuth("ADMIN"), hub.Conectar("notificaciones"))

// La cola es un ejecutor de un solo hilo: los trabajos se imprimen
// en orden y nunca dos a la vez sobre la misma impresora.
@Component
public class ColaImpresion {

    private final ExecutorService cola = Executors.newSingleThreadExecutor();
    @Value("${impresoras.cocina}") String ipCocina;   // 192.168.1.62
    @Value("${impresoras.caja}")   String ipCaja;     // 192.168.1.61

    public void encolarComanda(Pedido pedido) {
        encolar(ipCocina, TicketBuilder.comandaCocina(pedido));
    }
    public void encolarTicketCuenta(Pedido pedido) {
        encolar(ipCaja, TicketBuilder.cuentaCliente(pedido));
    }

    private void encolar(String ip, byte[] datosEscPos) {
        cola.submit(() -> {
            for (int intento = 1; intento <= 3; intento++) {
                try (Socket s = new Socket()) {
                    s.connect(new InetSocketAddress(ip, 9100), 3000);
                    s.getOutputStream().write(datosEscPos);
                    s.getOutputStream().flush();
                    return;                        // impreso ✔
                } catch (IOException e) {
                    log.warn("impresora {} intento {}: {}", ip, intento, e.getMessage());
                    try { Thread.sleep(2000L * intento); }
                    catch (InterruptedException ie) { return; }
                }
            }
            log.error("impresora {} inaccesible; trabajo descartado", ip);
            // aquí puedes difundir un aviso por /ws/notificaciones
        });
    }
}

// La cola es un canal + un goroutine consumidor: los trabajos se
// imprimen en orden y nunca dos a la vez sobre la misma impresora.
package impresion

type Trabajo struct {
    IP    string   // impresora destino
    Datos []byte   // bytes ESC/POS ya armados
}

type Cola struct{ trabajos chan Trabajo }

func NuevaCola() *Cola {
    c := &Cola{trabajos: make(chan Trabajo, 100)}
    go c.consumir()
    return c
}

func (c *Cola) consumir() {
    for t := range c.trabajos {
        var ok bool
        for intento := 1; intento <= 3; intento++ {
            if err := imprimir(t); err == nil {
                ok = true
                break
            }
            time.Sleep(time.Duration(intento) * 2 * time.Second)
        }
        if !ok {
            log.Printf("impresora %s inaccesible; trabajo descartado", t.IP)
            // aquí puedes difundir un aviso por /ws/notificaciones
        }
    }
}

func imprimir(t Trabajo) error {
    conn, err := net.DialTimeout("tcp", t.IP+":9100", 3*time.Second)
    if err != nil {
        return err
    }
    defer conn.Close()
    _, err = conn.Write(t.Datos)
    return err
}

func (c *Cola) EncolarComanda(p *Pedido) {
    c.trabajos <- Trabajo{IP: cfg.ImpresoraCocina,
        Datos: ComandaCocina(p)}   // arma los bytes (cap. 4.3)
}

src/main/java/com/turestaurante/
├── auth/            AuthController, JwtService, JwtFilter, RefreshTokenService
├── platillos/       PlatilloController, PlatilloService, PlatilloRepository, Platillo
├── pedidos/         PedidoController, PedidoService, PedidoRepository,
│                    Pedido, ItemPedido, dto/ (NuevoPedidoDTO, PedidoResponse…)
├── repartos/        RepartoController, UbicacionController (STOMP)
├── impresion/       ColaImpresion, TicketBuilder
├── ws/              WebSocketConfig, CanalCocina
└── config/          SecurityConfig, propiedades

src/main/resources/
└── application.yml  puerto, datasource, jwt.secret (desde env), IPs de impresoras

restaurante-api/
├── main.go            arma todo: config, hub, cola, rutas
├── auth/              jwt.go, middleware.go, login.go
├── platillos/         handler.go, service.go, repo.go, modelo.go
├── pedidos/           handler.go, service.go, repo.go, modelo.go, dto.go
├── repartos/          handler.go
├── impresion/         cola.go, tickets.go (arma bytes ESC/POS)
├── ws/                hub.go, handler.go
└── config/            config.go (lee env: puerto, BD, JWT_SECRET, IPs impresoras)

// El local se conecta a la nube como un cliente WebSocket más,
// autenticado con un token de servicio (no de usuario).
func MantenerTunel(hub *ws.Hub, cola *respaldo.Cola) {
    for {   // si se cae, reconecta para siempre
        conn, _, err := websocket.DefaultDialer.Dial(
            "wss://api.turestaurante.com/ws/tunel?token="+os.Getenv("TOKEN_SERVICIO"),
            nil)
        if err != nil {
            time.Sleep(5 * time.Second)
            continue
        }

        // ↑ subir eventos de respaldo pendientes (patrón outbox)
        go cola.EnviarPendientes(conn)

        // ↓ bajar lo que la nube reenvía (ubicaciones de repartidores)
        for {
            var msg ws.Mensaje
            if err := conn.ReadJSON(&msg); err != nil {
                break   // túnel caído → reintentar el Dial
            }
            if msg.Type == "UBICACION" {
                // se difunde al hub local: el mapa del escritorio
                // lo recibe SIN saber que vino de la nube
                hub.Difundir("ubicaciones", msg)
            }
        }
        conn.Close()
    }
}

// Spring puede ser cliente WebSocket, no solo servidor:
@Component
public class ConectorNube {

    private final CanalCocina canalLocal;      // difunde al hub local
    private final ColaRespaldo colaRespaldo;   // eventos pendientes
    // constructor…

    @Scheduled(fixedDelay = 5000)   // si no hay sesión viva, reintenta
    public void mantenerTunel() {
        if (sesionActiva()) return;
        var cliente = new StandardWebSocketClient();
        cliente.execute(new TextWebSocketHandler() {
            @Override
            public void handleTextMessage(WebSocketSession s, TextMessage m)
                    throws IOException {
                var msg = json.readTree(m.getPayload());
                if ("UBICACION".equals(msg.get("type").asText())) {
                    // el mapa del escritorio lo recibe del hub local
                    // sin saber que vino de la nube
                    canalLocal.difundirUbicacion(msg);
                }
            }
            @Override
            public void afterConnectionEstablished(WebSocketSession s) {
                guardarSesion(s);
                colaRespaldo.enviarPendientes(s);   // ↑ outbox
            }
        }, "wss://api.turestaurante.com/ws/tunel?token={t}", tokenServicio);
    }
}