Proyecto de separación de front-end y back-end: introducción a las notas de desarrollo de la interfaz de back-end

1. Crea un proyecto

1. Crea un nuevo proyecto maven

Si no hay ningún proyecto abierto, haga clic en Nuevo proyecto directamente . Si ya hay otros proyectos abiertos, haga clic en secuencia File -> New -> Project -> Maven, haga clic en Siguiente y cree un nuevo proyecto Maven (aquí estamos usando la versión 1.8 del SDK del proyecto).

Luego configuramos el proyecto Maven de la siguiente manera (puede encontrar el significado específico usted mismo)

• Nombre , nombre del proyecto
• Ubicación , la ruta de almacenamiento local del proyecto.
• GroupId , el grupo Maven generalmente está escrito al revés en el sitio web, también puede nombrarlo usted mismo, como cn.zhangsan
• ArtifactId , el nombre del módulo en el grupo.
• Versión , el número de versión del proyecto Maven.

Después de hacer clic en Finlandés (si se han abierto otros proyectos, aparecerá la ventana Abrir proyecto . Al seleccionar Esta ventana se cerrará el proyecto actual y se abrirá el proyecto creado. Al seleccionar Nueva ventana se abrirá el proyecto creado en una nueva ventana). el proyecto será creado

2. Construya SpringBoot

Usar SpringBoot es muy simple, solo necesitamos agregar la dependencia SpringBoot en pom.xml , el resultado final es el siguiente

• parent , establece SpringBoot como padre del proyecto actual, es decir, nuestro proyecto hereda SpringBoot
• properties , generalmente escribimos el número de versión de dependencia aquí y lo citamos directamente debajo para facilitar la administración de versiones.
• dependencias , lista de dependencias
• dependencia , dependencia

<?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 http://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>
    </parent>

    <groupId>com.jl15988</groupId>
    <artifactId>we-shopping</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

Para cargar las dependencias de Maven, debe hacer clic en el pequeño icono en la esquina superior derecha para introducir las dependencias en nuestro proyecto.

3. Crear interfaz

src\main\javaCree un nuevo paquete a continuación com.jl15988.shopping(el nombre del paquete suele ser el mismo que el nombre del grupo, o nombre del grupo + nombre del módulo, pero no puede estar en mayúscula), luego cree una clase WeShoppingApplication(nombrada aquí usando el nombre del proyecto + Aplicación) y agregue el siguiente código

package com.jl15988.shopping;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author Jalon
 * @since 2023/8/1 10:56
 **/
@SpringBootApplication
public class WeShoppingApplication {
    
    

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

com.jl15988.shoppingLuego cree controllerun paquete en, cree una clase en el paquete del controlador HelloControllery agregue el siguiente código

• @RestController , anotación, utilizada para indicar que la clase de controlador actual es
• @GetMapping , declara que este método es una Getsolicitud

package com.jl15988.shopping.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Jalon
 * @since 2023/8/1 10:59
 **/
@RestController
public class HelloController {
    
    

    @GetMapping("/hello")
    public String hello() {
    
    
        return "Hello World!";
    }
}

Luego podemos iniciar el proyecto, podemos hacer clic directamente en el WeShoppingApplicationtriángulo verde para iniciar el proyecto (si ha iniciado el proyecto, puede hacer clic directamente en el pequeño triángulo verde en la esquina superior derecha)

Luego, el navegador accede a localhost: 8080 / hola y la representación es la siguiente (si otros proyectos o programas ocupan el puerto 8080, se puede informar un error)

2. Interfaz de desarrollo

1. Crear base de datos

Crear una base de datos usando navicatwe_shopping

Luego ejecute la instrucción SQL para crear la tabla de datos.

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for sys_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user`  (
  `user_id` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
  `username` varchar(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
  `nick` varchar(26) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `email` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `create_time` datetime(0) NULL DEFAULT NULL,
  `update_time` datetime(0) NULL DEFAULT NULL,
  PRIMARY KEY (`user_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '用户' ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

2. Agregar herramientas de generación de código

Primero introduzca dependencias en el proyecto.

<!-- 数据库 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
<!-- mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</dependency>
<!-- lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<!-- mybatis-plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version>
</dependency>
<!-- 代码生成 -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.5.3.1</version>
</dependency>
<!-- 代码生成引擎模板 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-freemarker</artifactId>
    <version>3.1.0</version>
</dependency>

com.jl15988.shoppingLuego crea CodeGeneratoruna clase debajo y agrega el siguiente contenido

package com.jl15988.shopping;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.config.rules.DbColumnType;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import com.baomidou.mybatisplus.generator.fill.Column;

import java.sql.Types;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * @author Jalon
 * @since 2023/8/1 11:35
 **/
public class CodeGenerator {
    
    

    // 数据库地址
    private static final String URL = "jdbc:mysql://localhost:3306/we_shopping?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai";

    // 数据库用户名
    private static final String USERNAME = "root";

    // 数据库密码
    private static final String PASSWORD = "123456";

    // 生成代码的包名
    private static final String PACKAGE = "com.jl15988.shopping";

    // 作者
    private static final String AUTHOR = "Jalon";

    // 过滤的数据库名前缀
    private static final String[] PREFIXS = {
    
    "sys_"};

    public static void main(String[] args) {
    
    
        String projectPath = System.getProperty("user.dir");

        FastAutoGenerator.create(URL, USERNAME, PASSWORD)
                .globalConfig(builder -> {
    
    
                    builder.author(AUTHOR) // 设置作者
//                            .enableSwagger() // 开启 swagger 模式
                            .outputDir(projectPath + "/src/main/java") // 输出目录
                            .disableOpenDir(); //
                })
                .dataSourceConfig(builder -> builder.typeConvertHandler((globalConfig, typeRegistry, metaInfo) -> {
    
    
                    int typeCode = metaInfo.getJdbcType().TYPE_CODE;
                    if (typeCode == Types.SMALLINT) {
    
    
                        // 自定义类型转换
                        return DbColumnType.INTEGER;
                    }
                    return typeRegistry.getColumnType(metaInfo);

                }))
                .packageConfig(builder -> {
    
    
                    builder.parent(PACKAGE) // 设置父包名
//                            .moduleName("") // 设置父包模块名
                            .entity("domain.entity")
                            .pathInfo(Collections.singletonMap(OutputFile.xml, projectPath + "/src/main/resources/mapper")); // 设置mapperXml生成路径
                })
                .strategyConfig((scanner, builder) -> {
    
    
                    List<String> tables = getTables(scanner.apply("请输入表名，多个英文逗号分隔，所有表生成输入 all"));
                    builder.addTablePrefix(PREFIXS) // 过滤前缀
                            .addInclude(tables) // 增加表匹配
                            // controller配置
                            .controllerBuilder()
                            .enableRestStyle() // 添加@RestController
                            .enableHyphenStyle() // 驼峰转连字符
                            // 实体类配置
                            .entityBuilder()
                            .enableFileOverride() // 生成覆盖
                            .enableLombok() //添加lombok
                            .addTableFills(new Column("create_time", FieldFill.INSERT))
                            .disableSerialVersionUID() // 禁用生成 serialVersionUID
                            .idType(IdType.ASSIGN_ID) // 当用户未输入时，采用雪花算法生成一个适用于分布式环境的全局唯一主键
                            .build();
                })
                // 引擎模板，默认的是Velocity引擎模板
//                .templateEngine(new BeetlTemplateEngine()) // Beetl引擎模板
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板
                .execute();
    }

    // 处理 all 情况
    protected static List<String> getTables(String tables) {
    
    
        return "all".equals(tables) ? Collections.emptyList() : Arrays.asList(tables.split(","));
    }
}

Luego haga clic en el pequeño triángulo verde para iniciar el método principal en esta clase y luego ingrese en la consola allpara generar automáticamente las diversas clases que necesitamos, como se muestra a continuación (ignore application.yml aquí)

Toma nota, optimizado aquí

2. Escribir interfaz

Luego cree un archivo en los recursos del proyecto application.ymlcon el siguiente contenido (tenga en cuenta que debe modificar el nombre y la contraseña de su base de datos)

server:
  port: 8080
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/we_shopping?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
mybatis:
  mapper-locations: classpath:/mapper/*Mapper.xml

Luego com.jl15988.shoppingcree el paquete de entidad en el paquete y luego cree la clase de usuario de la siguiente manera

package com.myblog.entity;

import lombok.Data;

import java.util.Date;

/**
 * @author Jaon
 * @datetime 2021/10/29 16:13
 */
@Data
public class User {
    
    

    private Long id;

    /**
     * 用户名
     */
    private String username;

    /**
     * 密码
     */
    private String password;

    /**
     * 昵称
     */
    private String nick;

    /**
     * 邮箱
     */
    private String email;

    /**
     * 创建时间
     */
    private Date createTime;

    /**
     * 更新时间
     */
    private Date updateTime;
}

Cree el paquete del asignador en el paquete com.myblog y luego cree la interfaz UserMapper, de la siguiente manera

package com.myblog.mapper;

import com.myblog.entity.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * @author Jaon
 * @datetime 2021/10/29 16:09
 */
@Mapper
public interface UserMapper {
    
    

    List<User> list();
}

Cree el paquete del asignador en recursos y luego cree UserMapper.xml de la siguiente manera (la declaración SQL escrita aquí es para consultar todas las entradas en la tabla de usuarios de la base de datos. Si consulta todos los valores de los campos, no se recomienda utilizar el signo * (Se recomienda consultar todos los valores de los campos manualmente)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.myblog.mapper.UserMapper">
    <select id="list" resultType="com.myblog.entity.User">
        SELECT id, username, nick, email, create_time createTime, update_time updateTime
        FROM t_user
    </select>
</mapper>

Cree el paquete de servicio en el paquete com.myblog y luego cree la interfaz UserService de la siguiente manera

package com.myblog.service;

import com.myblog.entity.User;

import java.util.List;

/**
 * @author Jaon
 * @datetime 2021/10/29 16:11
 */
public interface UserService {
    
    

    List<User> list();
}

Cree el paquete impl bajo servicio, cree la clase UserServiceImpl e implemente la interfaz UserService de la siguiente manera

package com.myblog.service.impl;

import com.myblog.entity.User;
import com.myblog.mapper.UserMapper;
import com.myblog.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author Jaon
 * @datetime 2021/10/29 16:11
 */
@Service
public class UserServiceImpl implements UserService {
    
    

    @Autowired
    UserMapper userMapper;

    @Override
    public List<User> list() {
    
    
        return userMapper.list();
    }
}

Cree UserController bajo el controlador de la siguiente manera

package com.myblog.controller;

import com.myblog.entity.User;
import com.myblog.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @author Jaon
 * @datetime 2021/10/29 16:22
 */
@RestController
@RequestMapping("/user")
public class UserController {
    
    

    @Autowired
    UserService userService;

    @GetMapping("/list")
    public List<User> list() {
    
    
        return userService.list();
    }
}

Finalmente, cree un dato en la base de datos, reinicie el proyecto y acceda a localhost:8080/user/list

como en la base de datos

Acceder a los resultados (aquí uso el complemento CSDN, por lo que los datos devueltos se formatean automáticamente)

a. Formato de hora

Como se muestra en la figura, el formato de hora devuelto por el backend no coincide con el formato que realmente queremos, por lo que necesitamos convertir el siguiente formato: puede agregar directamente la anotación @JsonFormat en el atributo de clase de entidad.

/**
 * 创建时间
 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;

/**
 * 更新时间
 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;

b. Ocultar atributos con datos vacíos

Como se muestra en la figura, los datos devueltos que vemos contienen parámetros nulos. En algunos casos, podemos ocultar los parámetros nulos. Podemos usar la anotación @JsonInclude para lograr esto.

@Data
@JsonInclude(value = JsonInclude.Include.NON_NULL)
public class User {
    
    
    /* 省略代码 */
}

3. Implementar dominios cruzados

Si es un proyecto con front-end y back-end separados, si creamos un proyecto front-end para acceder a la interfaz actual, no será accesible porque las solicitudes entre dominios son causadas por diferentes direcciones o puertos. , necesitamos abrir solicitudes entre dominios en el back-end, como se muestra en la figura

Cree el paquete de configuración en el paquete com.myblog y cree la clase WebMvcConfig de la siguiente manera

package com.myblog.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author Jaon
 * @datetime 2021/11/1 9:54
 */
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    
    

    @Override
    public void addCorsMappings(CorsRegistry registry) {
    
    
        // 允许所有的路径可以跨域
        registry.addMapping("/**")
                // 允许所有来源都可以跨域
                .allowedOriginPatterns("*")
                // 允许跨域的请求
                .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
                // 允许证书凭证（如果这里设置为true，设置来源为所有只能使用allowedOriginPatterns）
                .allowCredentials(true)
                // 跨域时间3600秒
                .maxAge(3600)
                // 允许所以头标题
                .allowedHeaders("*");
    }
    }
}

Luego reiniciamos el proyecto, lo volvemos a visitar y descubrimos que el error entre dominios ha desaparecido y los datos se pueden devolver, como se muestra en la figura.

4. Manejo de excepciones globales

Como backend, incluso si se informa un error, es necesario devolver información de excepción para avisar al frontend. Sin embargo, en nuestro código, los datos transferidos entre la capa del controlador y la capa de servicio no pueden limitarse a un tipo de datos muy uniforme o el El servicio no tiene ningún valor de retorno. Esto da como resultado cierta información de excepción que no se puede devolver directamente desde la capa de servicio al front-end. Sería demasiado problemático usar try-catch para capturarla, por lo que definimos el manejo global de excepciones para que sea uniforme. capturar excepciones y devolverlas al front-end.

Como se muestra en la imagen, escribimos un código muy simple que definitivamente puede informar un error.

Luego, cuando accedamos a la dirección, encontraremos que se informa un error 500 y el mensaje de error se imprime en la consola.

Luego creamos el paquete de controlador en el paquete com.myblog y creamos la clase GlobalExceptionHandler, de la siguiente manera

package com.myblog.handler;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * @author Jaon
 * @datetime 2021/11/1 11:27
 */
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    

    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ExceptionHandler(Exception.class)
    public String handleException(Exception e) {
    
    
        return e.getMessage();
    }
}

Luego reinicie el proyecto, acceda a la dirección nuevamente y descubra que la información devuelta ha cambiado, lo que significa que detectamos la excepción y la devolvimos al front-end, pero no hay ningún mensaje de error en la consola.

A. Registro de errores

Para un proyecto de back-end, el registro de errores es muy importante y juega un papel decisivo en el mantenimiento posterior y la resolución de problemas, por lo que es un mal fenómeno que el procesamiento global de excepciones no imprima información de error. Podemos usar @Slf4j para implementar el registro de mensajes de error, de la siguiente manera

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    

    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ExceptionHandler(Exception.class)
    public String handleException(Exception e) {
    
    
        log.error("报错信息：{}", e.getMessage());
        return e.getMessage();
    }
}

B. Excepción personalizada

En nuestra lógica de negocios, es posible que necesitemos personalizar las excepciones para que sean lanzadas y manejadas por la clase de manejo de excepciones global. En este momento, considerando la diferencia en los códigos de estado devueltos y la información de excepción, necesitamos personalizar las clases de excepción para cooperar con el manejo de excepciones global. .

Cree el paquete common.lang en el paquete com.myblog y cree la clase MyBlogException de la siguiente manera

package com.myblog.common.exception;

import lombok.Getter;

/**
 * @author Jaon
 * @datetime 2021/11/1 12:32
 */
@Getter
public class MyBlogException extends RuntimeException {
    
    

    private Integer code;

    private String msg;

    public MyBlogException(Integer code, String msg) {
    
    
        super(msg);
        this.code = code;
        this.msg = msg;
    }

    public MyBlogException(Integer code, String msg, Throwable throwable) {
    
    
        super(msg, throwable);
        this.code = code;
        this.msg = msg;
    }

    public MyBlogException(String msg) {
    
    
        super(msg);
        this.code = 403;
        this.msg = msg;
    }

    public MyBlogException(String msg, Throwable throwable) {
    
    
        super(msg, throwable);
        this.code = 403;
        this.msg = msg;
    }
}

Luego podemos usar una clase de excepción personalizada para generar excepciones, como

Modificar la interfaz de la lista

@GetMapping("/list")
public List<User> list() {
    
    
    List<User> list = userService.list();
    if (list.size() <= 0) {
    
    
        // 如果数据库中没有用户信息则抛出异常
        throw new MyBlogException("当前没有用户信息");
    }
    return list;
}

Agregar método en la clase de manejo de excepciones global

@ExceptionHandler(MyBlogException.class)
public Map<String, Object> handleException(MyBlogException e) {
    
    
    log.error("报错信息：{}", e.getMessage());
    Map<String, Object> map = new HashMap<>();
    map.put("code", e.getCode());
    map.put("msg", e.getMsg());
    return map;
}

Luego elimine toda la información en la tabla de usuarios y luego solicite nuevamente. Puede ver que la interfaz recibió los resultados que queríamos.

5. Encapsulación unificada de datos devueltos.

Para proyectos con front-end y back-end separados, los datos devueltos por el back-end a menudo deben unificarse y estandarizarse para coordinarse con el procesamiento unificado de los datos del front-end.

Cree el paquete lang en el paquete común y cree la clase Resultado de la siguiente manera

package com.myblog.common.lang;

import lombok.Data;

/**
 * @author Jaon
 * @datetime 2021/11/1 13:14
 */
@Data
public class Result {
    
    

    private Integer code;

    private String msg;

    private Object data;

    public static Result success() {
    
    
        return success(null);
    }

    public static Result success(Object data) {
    
    
        return success(200, data);
    }

    public static Result success(Integer code, Object data) {
    
    
        return common(code, "操作成功", data);
    }

    public static Result fail() {
    
    
        return fail(null);
    }

    public static Result fail(Integer code, String msg) {
    
    
        return common(code, msg, null);
    }

    public static Result fail(String msg) {
    
    
        return common(400, msg, null);
    }

    public static Result fail(Integer code, Object data) {
    
    
        return common(code, "操作失败", data);
    }

    public static Result common(Integer code, String msg, Object data) {
    
    
        Result result = new Result();
        result.setCode(code);
        result.setMsg(msg);
        result.setData(data);
        return result;
    }
}

Luego reemplace todas las devoluciones con

// 修改接口返回值
@GetMapping("/list")
public Result list() {
    
    
    List<User> list = userService.list();
    if (list.size() <= 0) {
    
    
        throw new MyBlogException("当前没有用户信息");
    }
    return Result.success(list);
}

// 修改异常处理类返回值
@ExceptionHandler(MyBlogException.class)
public Result handleException(MyBlogException e) {
    
    
    log.error("报错信息：{}", e.getMessage());
    return Result.fail(e.getCode(), e.getMsg());
}

@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
@ExceptionHandler(Exception.class)
public Result handleException(Exception e) {
    
    
    log.error("报错信息：{}", e.getMessage());
    return Result.fail(e.getMessage());
}

Luego accedemos a la interfaz y podemos ver que el formato de devolución ha cambiado.

En este punto, el desarrollo de nuestra interfaz de entrada está completo.