Cómo publicar tu propia librería de Android en JCenter y Maven Central desde Android Studio

(Esta entrada sobre cómo publicar una librería es una traducción del artículo publicado en el blog The Cheese Factory. Podéis consultar el articulo aquí y darle a me gusta en su página de Facebook porque os aseguro que el contenido que publican es excepcional.)

Si en Android Studio quieres añadir cualquier librería a tu aplicación, basta con añadir la siguiente dependencia en el archivo build.gradle:

Y ya está. Ya puedes utilizar la librería.

Es alucinante. Pero, ¿nunca te has preguntado de dónde saca Android Studio la librería? En este artículo vamos a explicar en detalle su funcionamiento y además te enseñaremos a publicar tu propia librería para compartirla con otros desarrolladores, ¡lo cual no solo hará de este mundo un lugar mejor, sino que te convertirá en una persona mucho más guay!

¿De dónde saca Android Studio las librerías?

Comenzaremos con esta pregunta tan simple, ya que creo que no todo el mundo sabe de dónde las saca. ¿Acaso las busca automáticamente en Google y las añade a tu proyecto?

En realidad, no es nada complicado. Android Studio descarga las librerías desde el servidor de repositorios Maven que definimos en nuestro archivo build.gradle. (Apache Maven es una herramienta desarrollada por Apache que proporciona un servidor de archivos que permite su distribución). Básicamente, existen dos servidores estándares que alojan las librerías de Android: JCenter y Maven Central.

Ten en cuenta que, aunque tanto JCenter como Maven Central son repositorios estándares de librerías de Android, se encuentran alojados en lugares completamente diferentes y tienen proveedores distintos, por lo que no tienen nada que ver el uno con el otro. Aquello que se encuentra disponible en JCenter puede no estarlo en Maven Central y viceversa.

Además de estos dos servidores, también puedes indicar un servidor de repositorios Maven distinto para utilizar librerías de desarrolladores que las alojan en su propio servidor. Una librería de este estilo es Fabric.io de Twitter, que se encuentra alojada en su propio servidor Maven, en https://maven.fabric.io/public. Si quieres utilizar cualquiera de las librerías de Fabric.io, tienes que añadir el url del repositorio tú mismo de la siguiente manera:

Y entonces podrás acceder a las librerías alojadas en este repositorio de la misma forma:

Pero ¿qué es mejor: subir una librería a un servidor estándar o subirla a nuestro propio servidor? La respuesta correcta es la primera, ya que así haremos que nuestra librería esté disponible al público. Un desarrollador no debería tener que escribir nada más que una sola línea de código para indicar el nombre de una dependencia. Así que en este artículo nos centraremos únicamente en JCenter y Maven Central porque ambos ofrecen una muchísimo mejor experiencia para el desarrollador.

Debes saber que hay otro tipo de repositorio, además de Maven, que funciona con el Gradle en Android Studio. Se llama repositorio Ivy, pero por experiencia propia puedo decirte que no he visto a nadie utilizándolo, ni siquiera yo, así que no lo vamos a mencionar en este artículo.

Funcionamiento de JCenter y Maven Central

¿Sabes por qué hay dos tipos de repositorios estándares en lugar de uno solo?

En realidad ambos repositorios tienen la misma función: alojar librerías de Java/Android. Subir la librería a uno o a otro es algo que depende del desarrollador.

Originalmente, Andorid Studio escogió Maven Central como repositorio por defecto. Cuando se crea un proyecto en una versión antigua de Android Studio, se añade mavenCentral() automáticamente al build.gradle.

Pero el gran problema que tiene Maven Central es que no es fácil de usar para el desarrollador. Es increíblemente difícil subir una librería. Para hacerlo, el desarrollador debe tener cierto nivel de conocimientos. Y habiendo ya otras razones, como por ejemplo la preocupación por la seguridad, el equipo de Android Studio decidió cambiar de repositorio a JCenter. De hecho, puedes observar que cuando se crea un proyecto con versiones recientes de Android Studio, automáticamente se añade jcenter() al build.gradle en lugar de mavenCentral().

Aparte, había muchas otras buenas razones por las que decidieron cambiar de Maven Cetral a JCenter. Estas son algunas de las más importantes:

• JCenter utiliza CDN para distribuir sus librerías, lo que para el desarrollador significa una mayor rapidez de carga.
• JCenter es el mayor repositorio Java que hay sobre la Tierra. Así, el hecho de que algo esté disponible en Maven Central prácticamente implica que esté disponible también en JCenter. Es decir, que JCenter es un superconjunto de Maven Central.
• Resulta increíblemente fácil subir una librería a este repositorio. No es necesario firmar ni hacer nada complejo como teníamos que hacer en Maven Central.
• Interfaz de usuario fácil de usar.
• Si quieres subir tu librería a Maven Central, puedes hacerlo fácilmente con un solo clic desde Bintray (y con algún que otro paso más que solo tendrás que seguir la primera vez).

Por estos motivos y en base a mis propias experiencias, debo decir que me parece que cambiar de repositorio por defecto a JCenter fue una estupenda decisión.

Así que en este artículo nos centraremos solamente en JCenter, ya que una vez has subido la librería a JCenter, esta puede redireccionarse a Maven Center fácilmente.

¿Cómo obtiene Gradle las librerías de un repositorio?

Antes de comenzar a hablar sobre cómo subir una librería a JCenter, conviene explicar cómo descarga Gradle las librerías de un repositorio. Es decir, ¿cómo se bajan las librerías mágicamente cuando escribimos en el archivo build.gradle lo siguiente?

Básicamente, tenemos que saber cuáles son las parte de esta cadena utilizada para referenciar la librería. Consta de tres partes:

En este ejemplo:

• GROUP_ID: es com.codictados.utils.
• ARTIFACT_ID: es memory-util.
• VERSION: es 0.9.3.

En cuanto al significado:

• El GROUP_ID define el nombre del grupo de la librería. Puede que tengas varias librerías que sirvan para funciones distintas pero dentro de un mismo contexto. Si las librerías están en el mismo grupo, compartirán el mismo GROUP_ID. Por norma general, el GROUP_ID suele ser el nombre del desarrollador del paquete seguido del nombre del grupo de la librería. En nuestro ejemplo, “com.codictados” es el desarrollador, y “utils” es el grupo al que pertenece la librería. [N. del t.: para que la librería sera aceptada en JCenter, el GROUP_ID debe estar compuesto por tres palabras separadas por puntos, como en nuestro ejemplo.]
• Después, el nombre real de la librería se define en el ARTIFACT_ID. Nuestra librería se llama “memoryutil”.
• Y la VERSION no es más que el número de versión. Aunque puede ser cualquier palabra, te recomiendo que tenga un formato x.y.z. También puede ir seguido de -beta si quieres.

El siguiente ejemplo es una librería de Square. Fíjate en que se puede reconocer fácilmente el nombre del desarrollador y el de la librería:

¿Qué pasaría si añadieses estas dependencias a tu proyecto? Pues lo que pasaría sería que Gradle preguntaría al servidor de repositorios Maven si la librería existe. Si existe, Gradle obtendría la ruta a las librerías solicitadas, la mayoría con la nomenclatura GROUP_ID/ARTIFACT_ID/VERSION.

Con esta nomenclatura puedes encontrar, por ejemplo, la librería com.squareup:otto:1.3.7 en http://jcenter.bintray.com/com/squareup/otto/1.3.7 y https://oss.sonatype.org/content/repositories/releases/com/squareup/otto/1.3.7/.

Y entonces Android Studio descargaría esos archivos a nuestro ordenador y compilaría el proyecto. Y nada más. ¡Algo muy sencillo!

Tienes que entender que una librería que se obtiene de un repositorio no es más que un archivo jar o aar. Funciona de la misma forma que si descargas los archivos y los añades a tu proyecto a mano. Pero la gran ventaja que nos ofrece el sistema de dependencias de Gradle es que no tenemos que hacerlo a mano, sino que basta con añadir unas líneas de código. La librería se añadirá a nuestro proyecto con su propia versión.

¿Qué es el formato aar?

Un momento… He comentado que existen dos tipos de archivo de librería que se pueden subir a un repositorio: jar y aar. Un archivo jar no es algo que no conozcas ya. Pero ¿qué es exactamente un archivo aar?

Un archivo aar envuelve a un archivo jar. Se inventó porque una librería de Android necesita incluir archivos específicos de Android, como el AndroidManifest.xml, los recursos, los assets o los archivos JNI, y estos no van dento de un archivo jar estándar. Así que el aar se inventó para poder incluir todas estas cosas. Basicamente, es un archivo zip, igual que un jar pero con una estructura de archivos diferente. El archivo jar se incluye dentro con el nombre de classes.jar. Esta es la lista de archivos que contiene un aar:

• /AndroidManfest.xml (obligatorio)
• /classes.jar (obligatorio)
• /res/ (obligatorio)
• /R.txt (obligatorio)
• /assets/ (opcional)
• /libs/*.jar (opcional)
• /proguard.txt (opcional)
• /lint.jar (opcional)

Como puedes ver, un archivo aar está pensado para Android. Así que en este artículo te enseñaré a crear y a subir una librería en formato aar.

Cómo subir una librería a JCenter

Ya sabes todo lo necesario sobre cómo funciona el sistema de repositorios. Ahora empezaremos con la parte más importante: la subida, o lo que es lo mismo, cómo subir tu archivo de librería a http://jcenter.bintray.com. Cuando lo hagamos, la librería será publicada.

Ahora deben preocuparnos dos cosas: ¿cómo crear el archivo aar y cómo subuirlos archivos compilados al repositorio? Aunque esto requiere un montón de pasos, debo decir que no es muy difícil, ya que Bintray lo ha preparado todo muy bien. Aquí tienes el diagrama de todo el proceso:

Y como hay muchos detalles, voy a dividir el proceso en siete pasos para poder describirlos de forma clara y minuciosa.

Paso 1: Crear un paquete en Bintray

Lo primero es crear un paquete en Bintray. Para hacerlo, tendrás que disponer de una cuenta de Bintray y crear un paquete.

1. 1. Créate una cuenta en bintray.com (darse de alta es muy fácil, así que no lo voy a explicar).
   2. Después de registrarte, accede a tu cuenta y haz clic en maven. (Si no ves esta opción, pulsa en View all y selecciónala ahí).

1. 1. Pulsa sobre Add New Package para comenzar a crear un paquete para nuestra librería.

1. 1. Introduce toda la información solicitada.

[N. del t.: la mayoría de las librerías están subidas a la página de GitHub, ya que su sistema de versionado es muy popular, por lo que en los campos Website, Issue Tracker y Version control especificamos las páginas correspondientes de GitHub, pero si subes tu proyecto a otro repositorio, cambia esta información según tus necesidades.]

Aunque no hay ninguna regla para ponerle nombre a tu paquete (PackageName), podemos seguir cierta convención: utiliza solamente minúsculas y sustituye los espacios por guiones, como por ejemplo “memory-util”.

Cuando hayas rellenado todos los campos obligatorios, pulsa Create Package para terminar.

1. 1. Serás redireccionado a la página de edición de tu paquete. Haz clic en el nombre de tu paquete, debajo de Edit Package para ver los datos del paquete.

¡Y listo! Ahora ya tienes propio repositorio Maven en Bintray, esperando a que subas tu librería.

Ya hemos terminado con el proceso de registro en Bintray. Lo siguiente es Sonatype, el proveedor de Maven Central.

Paso 2: Crear una cuenta de Sonatype para Maven Central

Atención: puedes saltarte los pasos 2 y 3 si no piensas subir tu librería a Maven Central. De cualquier manera, te recomiendo seguirlos, ya que muchos desarrolladores aún utilizan este repositorio.

Al igual que en JCenter, si quieres publicar tu librería en Maven Central, tienes que crearte una cuenta en la página web de su proveedor, Sonatype.

Tu objetivo es crear una cuenta JIRA Issue Tracker. Para ello, ve al menú principal de Sonatype (System Dashboard) y regístrate para abrir una cuenta.

Cuando lo hagas, tienes que pedir permiso para publicar tu librería en Maven Central. Este proceso no tiene ningún sentido (o por lo menos eso me parece a mí), ya que lo único que tienes que hacer es publicar un issue en JIRA para que te dejen subir tu librería con el mismo GROUP_ID que el que se le va a proporcionar a Maven Central.

Para crear este issue tienes que ir al menú principal de Sonatype y pulsar Create, en la barra superior. Luego introduce los siguientes datos:

1. 1. • Project: Community Support – Open Source Project Repository Hosting
      • Issue Type: New Project
      • Summary: el nombre de tu librería. Por ejemplo “Memory Utils”.
      • Group Id: la raíz del GROUP_ID, por ejemplo, com.codictados. Cuando recibas la aprobación, podrás subir cualquier librería que comience por com.codictados, como por ejemplo com.codictados.estalibreria.
      • Project URL: el url de cualquier librería que desees subir. Por ejemplo, https://github.com/codictoados/codictados-rep.
      • SCM URL: el url del control de versiones. Por ejemplo, https://github.com/codictoados/codictados-rep.git.

Deja lo demás como está y pulsa Create. Y ya está. Ahora viene la parte más difícil… Esperar… normalmente al rededor de una semana o un poco más. Después ya tendrás permiso para publicar tu librería en Maven Central.

Por último, introduce tu nombre de usuario Sonatype OSS en la pestaña Accounts de tu perfil de Bintray.

Luego pulsa Update y habrás terminado.

Paso 3: Habilitar el firmado automático en Bintray

Como hemos dicho antes, podemos subir una librería a Maven Central desde JCenter, pero tenemos que firmar la librería primero. Bintray nos permite activar el firmado automático en su página web para que las librerás se firmen solas al subirlas.

Lo primero es generar la clave mediante una consola de comandos utilizando el siguiente comando (si tienes Windows, hazlo con cygwin):

Tendrás que rellenar algunos campos obligatorios. Para la mayoría de ellos se pueden utilizar valores por defecto, pero en otros tienes que introducir tú el valor correcto, como por ejemplo tu nombre, tu contraseña, etc.

Después de haber creado la clave, ejecuta el siguiente comando para comprobar los datos de la clave que has creado:

Si todo ha ido bien, deberías ver una información parecida a esta:

Ahora tenemos que subir esta clave pública a los servidores de claves para que sea funcional. Para ello, ejecuta el siguiente comando reemplazando PUBLIC_KEY_ID por el valor hexadecimal de ocho dígitos precedido de 2048/ que aparece en la línea pub, que en este caso es 01ABCDEF:

Y luego exporta tanto la clave privada como la pública en formato ASCII armor con el siguiente comando, reemplazando tu@email.com por el e-mail que has utiliado para crear la clave en el paso anterior:

Abre la página de edición de perfil de Bintray y haz clic en GPG Signing. Rellena los campos Public Key y Private Key con el contenido de los archivos public_key_sender.asc y private_key_sender.asc respectivamente.

Pulsa Update para guardar las claves.

Y el paso final es habilitar el firmado automático. Ve a la página principal de Bintray y haz clic en maven.

Pulsa Edit

Marca la casilla GPG Sign uploaded files automatically.

Pulsa Update y ya está. Ahora cualquier librería que subas a tu repositorio Maven se firmará automáticamente y estará lista para enviarla a Maven Central con un solo clic.

Fíjate en que esto solo tienes que hacerlo una vez y servirá para todas las librerías que crees.

Ya hemos dejado Bintray y Maven Central preparados. Ahora vamos a la parte de Android Studio.

Paso 4: Preparar el proyecto de Android Studio

En la mayoría de los casos puede que tengas que subir a tu repositorio más de una librería del mismo proyecto y al mismo tiempo puede que no tengas que subir nada. [N. del t.: no he entendido lo que quiere decir esto.] Por ello lo mejor que puedes hacer es dividir el proyecto en diferentes módulos. Mi recomendación es que tengas al menos dos módulos, el módulo aplicación, donde se hace hace un ejemplo de uso de la librería, y el módulo librería, que contendría solamente el código de la librería que quieres subir al repositorio. Fíjate en que puedes tener más de un módulo librería en cada proyecto, así que siéntete libre de crear otro módulo: lo ideal es tener un módulo por librería.

Doy por sentado que sabes crear un módulo librería, así que no voy a hablar de esa parte. Es tan fácil como seleccionar File > New > New Module… > Android Library.

Lo siguiente es añadir el plug-in de Bintray al proyecto. Para eso, tenemos que modificar el archivo build.gradle del proyecto y añadirle las dos últimas líneas:

Es importante que la versión de las build tools sea la 1.1.2 o superior, ya que en versiones anteriores hay un fallo de programación crítico. En este ejemplo usamos la versión más reciente, la 2.1.2.

A continuación modifica el archivo local.properties para definir el nombre de usuario y la clave API necesarias para la autenticación en Bintray y también la contraseña de la clave creada. El motivo por el cual ponemos estas propiedades en este archivo es porque se trata de información sensible que no debe ser compartida con nadie, ni siquiera con el control de versiones. Por suerte, el archivo local.properties se añade automáticamente a .gitignore al crear el proyecto, por lo que nunca se subirá al servidor por error.

Estas son las tres líneas que debes añadir:

En la primera línea introduce tu nombre de usuario de Bintray y en la segunda introduce la API Key que encontrarás en la página Edit Profile de Bintray. En la última línea introduce la contraseña que has utilizado para crear la clave GPG en el paso 3. [N. del t.: si has decidido no seguir los pasos 2 y 3 para subir a Maven, no es necesario que añadas la última línea, porque además, no dispondrás de ese valor.] Y guarda y cierra el archivo.

El último archivo que hay que modificar es el archivo build.gradle del módulo libería. Ábrelo y pega estas líneas después de apply plugin: 'com.android.library':

Aquí solo hemos definido una serie de variables que vamos a utilizar a continuación.

1. 1. • bintrayRepo: este es el tipo de repositorio que hemos escogido, así que deja maven.
      • bintrayName: es el nombre del paquete que has creado en Bintray.
      • publishedGroupId: es el GROUP_ID que formará parte de la forma de escribir la dependencia en el gradle. Recuerda que por convención está formado por el nombre del desarrollador y el nombre del grupo de la librería.
      • artifact: el ARTIFACT que formará parte de la cadena para declarar la dependencia en el gradle. Obligatoriamente debe ser el nombre de la carpeta raíz del modulo librería (es decir, “memoryutil” [mira la captura de pantalla de la estructura del proyecto más arriba]). De lo contrario, fallará la compilación.
      • libraryDescription: una descripción de la librería.
      • siteUrl: la página donde se encuentran los archivos de la librería.
      • gitUrl: la página del control de versiones.
      • libraryVersion: la versión de la librería.
      • developerId: el alias del desarrollador, o sea, el tuyo.
      • developerName: el nombre del desarrollador, o sea, el tuyo.
      • developerEmail: el correo electrónico del desarrollador, al que llegará el mensaje de Bintray cuando la librería sea publicada.
      • licenseName, licenseUrl y allLicenses: hacen referencia a la licencia que escogiste cuando creaste el repositorio.

Cuando se aplique el script que acabamos de definir, se podrá utilizar tu librería añadiendo la siguiente línea al gradle del proyecto donde quieras usarla:

El último paso es añadir dos scripts más necesarios para compilar los archivos que forman la librería y subirlos a Bintray. Para ello añade estas dos líneas tal cual al final del mismo archivo build.gradle del módulo librería:

Estos archivos se encuentran en GitHub y puedes añadirlos de esta forma o, si lo prefieres, puedes navegar a esas direcciones y copiar todo su contenido al final del build.gradle. De esta manera podrás ver qué estás indicando realmente.

¡Y ya está! Tu proyecto ya está listo para subirlo a Bintray.

Paso 5: Subir la librería a tu repositorio de Bintray

Ahora tenemos que subir la librería a nuestro repositorio de Bintray. Para ello, ve a la pestaña Terminal de Android Studio.

Lo primero es comprobar que el código sea correcto y compilar los archivos de la librería (aar, pom, etc). Para ello, ejecuta el siguiente comando:

Si todo va bien, deberías ver algo como:

[N. del t.: este proceso puede fallar si tienes fallos en el javadoc o en cualquier parte del código. Asegúrate de corregirlos todos. Además, suele dar fallos con clases de Android y anotaciones, pero si ha finalizado mostrando BUILD SUCCESSFUL, puedes continuar.]

Ya estamos a medio camino. El siguiente paso es subir los archivos compilados que acabamos de generar a Bintray con el siguiente comando:

Y si aparece lo que ves a continuación, ya puedes gritar “¡tomaaaa!”:

[N. del t.: este proceso puede fallar si en artifact no has puesto el nombre del módulo librería. También es posible que devuelva el error “No service of type Factory available in ProjectScropeServices”. En ese caso, cambia, en el build.gradle del proyecto, la versión de la dependencia 'com.github.dcendents:android-maven-gradle-plugin:1.3' por la 1.4.1.

]

Ve ahora a Bintray y comprueba tu paquete. Verás que hay un cambio en el apartado Versions.

Si haces clic en Files podrás ver los archivos de la librería que has subido. ¡Así que estupendo! Ya has subido tu librería y está lista para que cualquiera pueda usarla.

Pero no tan rápido… La librería solo se encuentra en tu repositorio Maven, pero todavía no está en JCenter. Si alguien quisiera utilizar la librería tal y como está, tendría que añadir tu repositorio al archivo build.gradle del módulo como vemos a continuación:

Puedes obtener la dirección url de tu repositorio Maven de la esquina superior derecha de la página del paquete que has creado en Bintray o sustituyendo “codictados” por tu nombre de usuario de Bintray en la dirección del ejemplo. Te animo a que, cuando crees tu repositorio, hagas clic en ese enlace para que veas lo que hay.

Como he dicho antes, no es una buena práctica hacer que un desarrollador tenga escribir un código complejo para utilizar una librería. ¿Te imaginas tener que añadir 10 librerías con el mismo método? Sería una pesadilla. Así que vamos a subir nuestra librería a JCenter para tener una mayor calidad de vida.

Paso 6: Sincronizar el repositorio de Bintray con JCenter

Sincronizar tu librería con JCenter es muy fácil. Solo tienes que abrir la página de tu paquete en Bintray y pulsar Add to JCenter.

Y lo único que hay que hacer es pulsar Send.

Ahora solo tenemos que esperar unas 2 o 3 horas hasta que el equipo de Bintray acepte nuestra petición. Una vez hayan aprovado la sincronización, recibiremos un e-mail en nuestra cuenta de Bintray y en nuestra cuenta de correo informándonos del cambio. [N. del t.: también pueden enviarnos un mensaje informándonos de por qué no aceptan la librería.] Si ahora vamos a la pantalla de nuestro paquete, veremos que, donde estaba el botón Link to JCenter, ahora en la sección Linked to habrá habido cambios:

Ahora, cualquier desarrollador que use el repositorio jcenter() podrá utilizar tu librería añadiéndo una sola línea al gradle:

compile 'com.codictados.utils:memoryutil:0.0.1'

Si quieres comprobar que tu librería se encuentra verdaderamente en JCenter, puedes ir a http://jcenter.bintray.com y buscar el directorio que coincida con el GROUP_ID y el ARTIFACT de tu librería. En nuestro caso tendríamos que abrir las carpetas com/codictados/utils/memoryutil/0.0.1.

Observa que solo tienes que sincronizar tu librería con JCenter una vez. Después, cada vez que modifiques tu paquete, por ejemplo, subiendo una nueva versión, borrando una versión antigua, etc., el cambio también afectará a JCenter. Pero dado que tu repositorio y el repositorio de JCenter son distintos, los cambios tardarán entre 2 o 3 minutos en sincronizarse.

Y ten cuidado. Si decides eliminar todo el paquete, los archivos de librerías que haya en el repositorio de JCenter no se borrarán. Permanecerán como una librería zombie y nadie podrá borrarla nunca. Así que cuando quieras borrar todo el paquete, borra primero todas las versiones que hayas subido a Bintray primero y luego borra el paquete.

Paso 7: Redireccionar la librería a Maven Central

No todos los desarrolladores utilizan JCenter. Muchos todavía siguen usando mavenCentral(), así que vamos a subir nuestra librería a Maven Central también.

Para redireccionar la librería desde jCener a Maven Central, hay que hacer previamente dos cosas:

1. 1. 1. Tu paquete de Bintray tiene que estar vinculado con JCenter
      2. Deben haber aprobado tu petición de abrir un repositorio de Maven Central

Si ya has hecho esto, lo que queda es muy fácil. Abre el enlace de Maven Central en la página de detalles de tu paquete.

Introduce tu nombre de usuario y tu contraseña de Sonatype y pulsa Sync.

Cuando lo hagas, verás que el valor del campo Last Sync Status cambia a Successfully synced and closed repo. Si algo falla, el motivo aparecerá en Last Sync Errors. Tendrás que solucionar todos los problemas uno a uno, ya que son muy estrictos con los requisitos para subir una librería a Maven Central. Por ejemplo, no se puede utilizar el carácter ‘+’ en la parte VERSION de la cadena que referencia la librería.

Después de esto podrás encontrar tu librería en el repositorio de Maven Central buscando el directorio que coincida con el GROUP_ID y el ARTIFACT de tu librería. En nuestro caso tendríamos que abrir las carpetas com/codictados/utils/memoryutil/0.0.1.

¡Y, por fin, eso es todo! Aunque son muchos pasos, son pasos muy directos y la mayoría de ellos solo hay que realizarlos una vez. Después prácticamente no tienes que hacer nada más.

Espero que te resulte útil y ver algún día tu librería en un repositorio. ¡Suerte!