You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

2 Días
11 Hrs
46 Min
39 Seg

Creación del proyecto y API KEY

17/25
Resources

How to get a CatAPI API Key?

To work with the CatAPI, you first need to obtain an API Key. This code is essential to authenticate you and make requests to the API. Here's how to get it:

  1. Go to the CatAPI website (catapi.com).
  2. Register using your email address.
  3. You will receive an email with your API Key. It is very important to keep this key secret, as it secures your connection to the API.

How to start the structure of a project?

We are going to use NetBeans to develop the structure of our Java project, which will include integrations with the CatAPI.

Creating the project in NetBeans

  1. Open NetBeans and create a new project called CatData.
  2. Make sure to correctly configure the project according to your initial preferences.

Adding dependencies to the project

To interact with the CatAPI, you need two dependencies:

  • OkHttp: This is the HTTP client that allows you to send requests to the APIs.
  • Gson: It will help you transform JSON responses into manageable objects in Java.

Here I show you how to add them:

<!-- OkHttp dependency --><dependency> <groupId>com.squareup.okhttp</groupId> <artifactId>okhttp</artifactId> <version>2.7.5</version></dependency>
<!-- Gson dependency --><dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.6.0</version></dependency>

How to develop the key classes and methods?

Model class: CatData

You must create a class to represent the basic data of a cat and, in it, include the following attributes:

public class DatosGato { private int id; private String url; private String apiKey; // Insert here your API Key obtained private String image;    
 // Generate getters and setters}

Startup class: Startup

This class will handle the GUI and the menu using the Java JOptionPane class. The menu control loop will be fragmented here:

public class Home {
 public static void main(String[] args) { String[] options = {"View Cats", "Exit"};        
 int optionSelected; do { optionSelected = JOptionPane.showOptionDialog(null, "Select an option", "Main Menu", JOptionPane.DEFAULT_OPTION, JOptionPane.INFORMATION_MESSAGE, null, options, options[0] ); switch (optionSelected) { case 0: // Call method to view data break; case 1: // Exit System.exit(0); } } } while (optionSelected != 1); } }}

Service class: DatosService

This class will be in charge of containing the logic to interact with the API and process the information:

public class DatosService {
 public void verDatos() { // Logic to get and display data from the API }}

How to integrate everything and run the project?

Once you have set up the dependencies and created the necessary classes, proceed to integrate the interaction methods and visual logic when running the project. Upon completing the above steps, confirm that the menu is executed correctly, checking that the options respond as expected.

With this approach, you will not only learn how to use CatAPI, but also how to apply Java development practices that will help you advance as a programmer. Keep exploring and expanding this project to improve your skills - success on your learning journey!

Contributions 34

Questions 6

Sort by:

Want to see more contributions, questions and answers from the community?

Una anotación adicional sobre buenas prácticas: las claves, contraseñas, keys, etc., no deben quemarse en el código sino que se recomienda manejar un archivo aparte que las coleccione. Ese archivo simplemente se lee de manera local y no se almacena en el repositorio (para no exponer información sensible, a menos que el repositorio sea privado o permita ocultar archivos; en ese último caso se puede incluir)

No entiendo la necesidad de crear tanto codigo y compejidad solamente en la validacón innecesaria de los datos, si con el showOptionDialog puedes ofrecer 2 opciones mediante el boton y condicionarla en el switch sin tener tantas cosas con un ciclo for y un while.

Personalmente no me gusto la forma en la que el profesor estructuró la acplicacion, por eso les propongo el siguiente modelo:

Para seguir la idea de que la app tiene que:
a. estar separada en capas
b. cada parte de nuestra app tiene que tener un orden logico
c. las clases tienen que estar organzidas

Les prongo este modelo:

| GUI +---+
+-----+   |    +----+   +---------+   +-----+
          +--->| UI +-->| Service +-->| DAO |
+-----+   |    +----+   +---------+   +-----+
| CLI +---+
+-----+

GUI: (graphical) What you interact with
CLI: (non-graphical) What you interact with

UI: What decides what to do based on the output (what you unconsciously interact with)
Service: What processes the data
DAO: What communicates with the API/DB

Finalmenente, para este proyecto podriamos usar una estructura como esta:

.
├── App.java
├── cats
│   ├── CatDAO.java
│   ├── Cat.java
│   └── CatService.java
└── ui
    ├── cli
    │   └── CLI.java
    ├── gui
    │   └── GUI.java
    └── UI.java

5 directories, 7 files

Deberian actualizar los cursos!

¿porque no encapsulo los atributos? 😕

Mi versión, un poco mas corta:

int optionSelected = -1;
        ArrayList<String> options = new ArrayList<>();
        options.add(" 1. ver gatitos");
        options.add(" 2. salir");
        do{
            Object input = 
JOptionPane.showInputDialog(
null, "Gatitos java", "Menu principla", JOptionPane.INFORMATION_MESSAGE, null, options.toArray(),options.get(0)
);
            optionSelected = options.indexOf(input);
            if(optionSelected == 0){
                GatosService.verGatos();
            }
        }while (optionSelected != 1);
Habría sido una buena opción que enseñara cómo crear una variable de entorno para almacenar el API Key y llamarla desde nuestro programa Java para poder esconder el API Key y así poder esconderlo de manera satisfactoria tanto en el vídeo (evitar la censura) como en un repositorio público de GitHub o GitLab

Super 😃

<dependencies>
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>4.2.2</version>
    </dependency>
</dependencies>

Actualizacion de esto urgente por favor.

Interesante clase, me gusto la parte de crear un menú que se muestre por medio de una ventana emergente al usar el JOptionPane y también al establecer la llave de formar directa por medio de la variable String.

Para los que están usando IntelliJ, que configuración de compilado usan?

Estudiantes, actualicé el proyecto en mi repositorio aplicando mejores prácticas

Buena explicación excelente

este curso esta super genial!

Alguien sabe como agregar la dependenci de OKHTTP en intelliJ IDEA??? ya busque bastante pero no logro encontrar respuesta…

Para los interesados en utilizar el api de cachorros les dejo el enlace: https://docs.thedogapi.com/

Con ayuda de los comentarios y otras fuentes, pude resumir esta clase lo más que pude, comprendo que el profesor no tenga tiempo para actualizar pero para eso somos una gran comunidad. Les dejo mi código

<String[] opcion= {"Ver Gatitos", "Salir"};
        int selectedOption = JOptionPane.showOptionDialog(null, "Selecciona una opción", "Gatitos APP", JOptionPane.DEFAULT_OPTION, JOptionPane.INFORMATION_MESSAGE, null, opcion, opcion[0]);
        
        if(selectedOption==0){
            System.out.println("Elegiste la opcion de gatitos");
        
        }else if(selectedOption== 1) {
            System.out.println("Elegiste salir");
        }> 

el ciclo for con el if lo resumí con esta linea:

/*for(int i=0; i < botones.length; i++){
                if(opcion.equals(botones[i])){
                    opcion_menu = i;
                }
}*/
opcion_menu = Arrays.asList(botones).indexOf(opcion);

Atajo de teclado Netbeans
 

Escribir: psvm y pulsar la tecla TAB

 
generara de forma automética el código para el método main

 
Espero pueda ser de utilidad

![](https://static.platzi.com/media/user_upload/image-b5057cb4-b6f9-4dfe-831d-ede6c0ce5c4e.jpg)
No es recomendable dejar datos sencibles en sus repositorios. Para evitarlo usen variables de entorno en sus proyectos. En este caso sigan los siguientes pasos: 1. Agreguen la extensión [Dotenv Java](https://mvnrepository.com/artifact/io.github.cdimascio/dotenv-java) 2. En la raíz del proyecto, osea, en la carpteta principal creen un archivo con el nombre .env 3. Dentro de el escriban las variables secretas. Por convensión se nombran todas en mayusculas y separadas por guion bajo. No escriban comillas. Por ejemplo: API\_KEY=aqsdfghjkqwerg 4. Donde requieran leer algun valor que este en .env deben llamar la dependencia y luego guardar como variable sus datos. Por ejemplo, en la clase Gatos: `package org.jlz;` `import io.github.cdimascio.dotenv.Dotenv;` `public class Gatos {` ` Dotenv dotenv = Dotenv.``load``();` ` String myEnvVar1 = dotenv.get("API_KEY");` `}`
Me emocioné al ver la ventana de JOptionPane después de años, me hizo acordar aquellos tiempos cuando competíamos con los compañeros de clase ![](https://static.platzi.com/media/user_upload/image-4cbb5467-5bb7-4c30-ad0e-00aa7d9e0122.jpg)

Un super video de JOptionPane: https://www.youtube.com/watch?v=VFAG5uedkm4

Serializar: la respuesta que obtenemos de la api, convertirla en un arreglo u objeto dentro de Java para poder manipular los datos.

El JOptionPane.showInputDialog() permite solicitar datos al usuario y personalizar nuestra ventana

Quizás esta lógica ayude un poco más a quienes ven por primera vez este vídeo. Salu2.

Descarguen específicamente las dependencias explicadas en esta clase para evitar problemas con las últimas actualizaciones

Bien conociendo ya un poco la posibilidad de herramientas visuales que nos brinda java.

Por si la api de gatos que está presentando problemas, aún los sigue teniendo, pueden probar con la api https://dog.ceo/dog-api/.
El usuario @CansecoWill también lo publicó en este comentario.
https://platzi.com/comentario/1116230/

Algo importante a tener en cuenta de cara al formateo del código y a tenerlo organizado, es que casi todos los IDE actuales ofrecen opciones de formato automático, o lo que se llama linter. Esto permite tener el código organizado sin perder tanto tiempo intentando hacerlo manualmente.

Genial.

Para los que les gusta hacer esto a mano, aqui tienen el link para descargar los jars:
okhttp: https://search.maven.org/artifact/com.squareup.okhttp/okhttp-urlconnection/2.7.5/jar
gson: https://search.maven.org/artifact/com.google.code.gson/gson/2.8.6/jar

Que debe tener una llave primaria para que no se envíe la inserción de datos?

El código se puede reducir, pero para tener una base está excelente.