Docker, Intermediate

Docker-Compose for Grails Developers: Part 1

Hi people.

In the last four years, we have saw the evolution of Docker, and many videos, posts and events about that. I’m not going to present (another time) the advantages of Docker. If you want to know some of them, you can read them here, and here, and here….

My focus in this post series is how Docker, and mainly Docker Compose can be used by Grails Developers in order to achieve a faster, reproducible and secure development environment. As an IT Analyst, one of the main problems that I had to face in my professional life was WOMM (Works On My Machine).

Not possible... It works on my machine!
Not possible… It works on my machine!

This kind of problem is very common in the IT world. It occurs because developers configure their own development environment. So they choose their operational system, add things in the database, have their own jars, a specific Java Virtual Machine version and many other things to guarantee that the new feature works! But, the best part, they don’t even know the things they have done in order to “make it work”. And of course, when then they run this feature in another machine, it doesn’t work!

Another problem that occurred sometimes is DIG (Database Is Gone). This occurs when accidentally someone drops the shared database! Or if destroys some important data. Believe me, these are not a good things to do!

Where is the database? Oh... I dropped it!
Where is the database? Oh… I dropped it!

So, in order to try to avoid these “events” to happen, I started searching viable solutions. I wanted a way to create the “same” environment to all developers of my team. But I also wanted to enable them to recreate this environment many times if needed, and in a very fast way! So I found this video, from Iván López. He presented an easy way to use Docker, in order to develop Grails applications. I tried to follow his tips, and sooner than latter I was able to reproduce his presentation. I had I Dockerfile, running Grails. Recently, I decided to share it with the world, and create this repository. The source code can be found here.

Then, I used the same Dockerfile to install Postgres, as Iván López suggested. But with the time, our team came to the conclusion that the development environment could not be done in only one Dockerfile, because we had Grails as backend, AngularJS as frontend, Postgres, OpenLDAP, Redis, and other systems…. So, our Dockerfile would have to be VERY BIG in order to install all those systems. Also, if we needed to change Grails version, for instance, we would have to build all the commands in that Dockerfile. Moreover, we had no easy way to follow the logs from all those systems. Definitely it was not viable.

So I decided to “translate” our environment to Docker Compose. But, was Docker Compose the right tool to use in an development environment?

Was Docker compose the right decision!?
Was Docker compose the right decision!?

The fist try was something like this:

version: '2'
services:
  grails:
    image: vaidegrails/grails:latest
    command: tail -f /dev/null
    volumes:
      - ~/.m2:/home/developer/.m2
      - ~/.gradle:/home/developer/.gradle
      - ~/.grails:/home/developer/.grails
      - ~/.ssh/:/home/developer/.ssh
      - ~/git/:/home/developer/git
    ports:
      - "8888:8080" #Grails default port mapped to my local port 8888
      - "5005:5005" #Grails debug port mapped to my local port 5005
    links:
      - db
  db:
      image: postgres:9.6
      ports:
        - "7777:5432" #Postgres default port mapped to my local port 5432
      environment:
        - POSTGRES_PASSWORD=vaidegrails

If you don’t know Docker Compose, let me explain what all does this mean. First of all, version: ‘2’ defines the version of docker compose file we are using. In this case, version 2. The most recent version is 3 (and this code is compatible with that).

Then, we have a section services, in which we define 2 services (that will be provided by different containers): grails and db. Grails is the container that we will use to run Grails commands, like:

  • grails run-app (or grails r-a)
  • grails test-app (or grails t-a)
  • grails clean
  • grails compile

DB is the database service, in our case, an instance of the Postgres DB, version 9.6.

In Grails service, the container will run the same image of Docker that I created (vaidegrails/grails), in its most recent version (latest). With the block command, we choose which command that will run when the container starts. In this case, we are running tail -f /dev/null. This command runs forever, so our container never stops.

In volumes block, we map directories of our machine to the container. So my local directory ~/.m2 will be mapped in the container’s /home/developer/.m2 directory. It is the Maven local repository in which Grails will download all the projects dependencies. If we don’t map it, each time that we restart the container, and try to run our projects, Grails will have to download all the dependencies again. The same applies to .gradle and .grails directories.

We can map our .ssh directory, for example, to use git with our own ssh public key. The last directory, git, is the directory in my machine that I put all my projects. This way, I can open all my projects in the container. However, you can choose whatever directory you want.

In ports section, we map the containers exposed ports (in the Dockerfile) to our local ports. So, I’ll be to access my Grails running application in my browser entering in http://localhost:8888. You can choose any port you want.

The links section defines that our Grails container is able to access the DB container. How we didn’t define an alias, the DB container can be accessed in the host db. For instance, to connect to Postgres default port (5432), we have to access this host:

db:5432

This information will be used in our application.yml (we will see how in the next post). The db container, like I said, will use postgres:9.6 image, and will have its 5432 port mapped to our local 7777 port. The enviroment section defines environment variables that will be passed to the image. In our case, we define POSTGRES_PASSWORD variable, with the value “vaidegrails“. This way, our postgres user will be able to access the database with the password “vaidegrails“.

We didn’t define any network for our services, so Docker will automatically create a network and put the two services in the same network. If we need, we can specify different networks for our services, but we won’t do it now.

To run this docker-compose file (the name of the file must be docker-compose.yml), we only need to enter on the directory it is and use the following command:

docker-compose up

Or, if we are at another directory, we can specify the full path of the docker-compose.yml file using the parameter -f. With this command, the docker-compose file can be named in a different way:

docker-compose -f full_path_to_the_docker_compose_file up

When you run one of those commands, you will see a log like this:

db_1      | The files belonging to this database system will be owned by user "postgres".
db_1      | This user must also own the server process.
db_1      |
db_1      | The database cluster will be initialized with locale "en_US.utf8".
db_1      | The default database encoding has accordingly been set to "UTF8".
db_1      | The default text search configuration will be set to "english".
db_1      |
db_1      | Data page checksums are disabled.
db_1      |
db_1      | fixing permissions on existing directory /var/lib/postgresql/data ... ok
db_1      | creating subdirectories ... ok
db_1      | selecting default max_connections ... 100
db_1      | selecting default shared_buffers ... 128MB
db_1      | selecting dynamic shared memory implementation ... posix
db_1      | creating configuration files ... ok
db_1      | running bootstrap script ... ok
db_1      | performing post-bootstrap initialization ... ok
db_1      | syncing data to disk ... ok
db_1      |
db_1      | Success. You can now start the database server using:
db_1      |
db_1      |     pg_ctl -D /var/lib/postgresql/data -l logfile start
db_1      |
db_1      |
db_1      | WARNING: enabling "trust" authentication for local connections
db_1      | You can change this by editing pg_hba.conf or using the option -A, or
db_1      | --auth-local and --auth-host, the next time you run initdb.
db_1      | waiting for server to start....LOG:  could not bind IPv6 socket: Cannot assign requested address
db_1      | HINT:  Is another postmaster already running on port 5432? If not, wait a few seconds and retry.
db_1      | LOG:  database system was shut down at 2017-04-24 11:31:54 UTC
db_1      | LOG:  MultiXact member wraparound protections are now enabled
db_1      | LOG:  database system is ready to accept connections
db_1      | LOG:  autovacuum launcher started
db_1      |  done
db_1      | server started
db_1      | ALTER ROLE
db_1      |
db_1      |
db_1      | /usr/local/bin/docker-entrypoint.sh: ignoring /docker-entrypoint-initdb.d/*
db_1      |
db_1      | LOG:  received fast shutdown request
db_1      | LOG:  aborting any active transactions
db_1      | waiting for server to shut down...LOG:  autovacuum launcher shutting down
db_1      | .LOG:  shutting down
db_1      | LOG:  database system is shut down
db_1      |  done
db_1      | server stopped
db_1      |
db_1      | PostgreSQL init process complete; ready for start up.
db_1      |
db_1      | LOG:  database system was shut down at 2017-04-24 11:32:08 UTC
db_1      | LOG:  MultiXact member wraparound protections are now enabled
db_1      | LOG:  autovacuum launcher started
db_1      | LOG:  database system is ready to accept connections

This mean that our service db (with a Postgres instance) is running. We can check our services with this command:

CONTAINER ID        IMAGE                                                                    COMMAND                  CREATED             STATUS              PORTS                                                                    NAMES
b5db5ab813c1        vaidegrails/grails:latest                                                "tail -f /dev/null"      2 minutes ago       Up 2 minutes        0.0.0.0:5005->5005/tcp, 0.0.0.0:8888->8080/tcp                         bruno_grails_1
09bd98c12dea        postgres:9.6                                                             "docker-entrypoint..."   2 minutes ago       Up 2 minutes        0.0.0.0:7777->5432/tcp                                                  bruno_db_1

We can see the container id, the name of the image that is running in each container, the command that is running, the time it was created, the container status (if is running or not), the ports that are mapped in it and the name assigned to the container. The name is composed by the name of the directory  of the docker-compose file (in our case bruno), the name of the service (grails or db), and the number of the instance.

Now we have our development environment running. To stop it, we can use:

docker-compose down

Or:

docker-compose -f full_path_to_the_docker_compose_file down

It will stop all the services:

Stopping bruno_grails_1 ... done
Stopping bruno_db_1 ... done
Removing bruno_grails_2 ... done
Removing bruno_grails_1 ... done
Removing bruno_db_1 ... done
Removing network bruno_default

In the next post, we will see how can we configure our Grails application to connect with the database, and how we develop using the Grails container.

“Therefore, it is better for two to be together, than for one to be alone. For they have the advantage of their companionship. If one falls, he shall be supported by the other. Woe to one who is alone. For when he falls, he has no one to lift him up. And if two are sleeping, they warm one another. How can one person alone be warmed? And if a man can prevail against one, two may withstand him, and a threefold cord is broken with difficulty.” Ecclesiastes 4:9-12 https://www.bible.com/42/ECC.4.9-12

Docker

How to enable VisualVM to profile your Grails app

Hi people,

This is my first post in english. Here, in Vai de Grails!, my objective is to let people discover Grails, and all its powerful capabilities. Inspired by this thread I began to search for an open source application to profile my Grails applications. After finding VisualVM, I had to discover how to use it with Grails App. Happily, it is very easy!

In this post, I’ll show how to configure your Grails application (in development mode) in order to use VisualVM to profile it. I won’t cover how do you use VisualVM features. VisualVM is an open source application that can display Java process running locally or remotely, show information about the environment, and process configuration, monitor memory and process performance.

In Grails versions 2.5.x (in a later post, we will see how to do this with Grails 3.2.x applications), if you are running you application locally, then you only need to open your Visual VM, and you should see two process in Local that are started by Grails: org.codehaus.groovy.grails.cli.support.GrailsStarter and org.grails.plugins.tomcat.fork.ForkedTomcatServer. If you double-click ForkedTomcatServer, a tab will be opened, and you’ll be able to see information about the process, like PID, Java Version, JVM Arguments, as shown in this picture:

Information about your process.
Information about your process in VisualVM.

You can click in other tabs to see data about Threads, Memory Pools and other important things. But, if you are like me, that use Docker to configure your development environment, than you need to do some configuration in order to use VisualVM.

You can see how do I configure the development environment in Docker in this link (Portuguese version).

In versions 2.5.x of Grails, the first thing to do is add the following code to your BuildConfig.groovy:

grails.tomcat.jvmArgs = [
        "-Dcom.sun.management.jmxremote", "-Dcom.sun.management.jmxremote.port=9292",
        "-Dcom.sun.management.jmxremote.local.only=false", "-Dcom.sun.management.jmxremote.authenticate=false",
        "-Dcom.sun.management.jmxremote.ssl=false"
]

With this code, we are configuring the Tomcat plugin to enable JMX (Java Management Extensions), an API to manage and monitor resources like applications, devices, services and the JVM. It includes the possibility to remote access, so a remote management program can interact with an application in execution, and show data about the application, and the system in which it is running.

We pass a list of JVM Arguments. Let’s see what they represent:

  • -Dcom.sun.management.jmxremote – Enables the JMX API
  • -Dcom.sun.management.jmxremote.port=9292 – Defines which port will be open in order to allow the access to the API. You can choose any open port of your computer. The same value must be configured in Visual VM (we will see how to do this). In our example we will consider 9292 like the port used.
  • -Dcom.sun.management.jmxremote.local.only=false – Permits remote access to the API
  • -Dcom.sun.management.jmxremote.authenticate=false – Don’t use authentication in the API, so, we don’t need to configure an user and its password
  • -Dcom.sun.management.jmxremote.authenticate.ssl=false – Don’t use SSL. This way, we don’t need to configure an SSL certificate

Docker environment must be started with a link to port 9292 (see this link to understand this configuration)

docker run -i -t eu/meu-ambiente-grails:1.0.0 -p 8888:8080 -p 9292:9292 -v $HOME/git:/home/developer/git -v $HOME/.ssh:/home/developer/.ssh /bin/bash

Note that if you use docker-compose to define your environment, than you have to link the port using the docker-compose syntax. You have to run your Grails app (grails run-app), wait until it is ready and then, you must open VisualVM and click in “Local” with the right button of the mouse, and select “New JMX Connection…”.

Clik in Local (highlighted in the image) with the right button of the mouse, and select "New JMX Connection..." to create a connection with the Tomcat running the Grails applications.
Click in Local (highlighted in the image) with the right button of the mouse, and select “New JMX Connection…” to create a connection with the Tomcat running the Grails applications.

Then you must fill the form as it is shown in the following picture:

You must use localhost: in Connection. PORT_NUMBER is the same number that you used in BuildConfig.groovy. Also, you must select "Do not require SSL connection"
You must use localhost: in Connection. PORT_NUMBER is the same number that you used in BuildConfig.groovy. Also, you must select “Do not require SSL connection”

It is important to notice that the port number must be the same number that you used in BuildConfig.groovy, defined by this configuration “-Dcom.sun.management.jmxremote.port“. If you witsh, you can set up a Display Name, selecting the respective field. With the new connection, you can double-click in it, and start monitoring your application!

With the generated connection, you can start monitoring your application!
With the generated connection, you can start monitoring your application!

I hope you liked this post. Feel free to comment!

“Verily I say unto you, that this generation shall not pass, till all these things be done. Heaven and earth shall pass away: but my words shall not pass away. But of that day and that hour knoweth no man, no, not the angels which are in heaven, neither the Son, but the Father. Take ye heed, watch and pray: for ye know not when the time is.” Mark 13:30-33 https://www.bible.com/1/MRK.13.30-33

Uncategorized

Conheça os ganhadores do concurso Show Us Your Grails

Pessoal,

Recentemente a OCI (casa do Grails) fez um concurso interessante chamado “Show Us Your Grails”. Nele, as pessoas podiam inscrever aplicações (sites) que elas fizeram utilizando Grails.

Eu achei essa uma sacada muito boa da OCI, pois mostra ao mundo que o Grails é sim utilizado em diversos projetos, inclusive de grande porte. Pois bem, muitas pessoas se inscreveram, e agora saiu o resultado oficial.

O grande ganhador foi o site Scentbaquiird, cuja ideia (pelo que eu entendi) é ter um PaaS (Perfume as a Service :D). Em vez de você comprar um perfume, você pode pagar mensalmente para receber sua cota de perfume. Ou seja, pague só no mês que você quiser ter um cheirinho especial! Além disso, você pode escolher entre mais de 450 tipos de perfumes. O site usa um layout bem moderno e fluido e tem mais de 100 mil usuários.

Para conhecer os outros projetos que se destacaram, entrem aqui. Agora se te falarem falácias como “ninguém usa Grails”, ou “Grails é para projetos pequenos” você já sabe muito bem como responder!

Abraços e até a próxima!

 

Foi-lhe dada sepultura ao lado de fascínoras e ao morrer achava-se entre malfeitores, se bem que não haja cometido injustiça alguma, e em sua boca nunca tenha havido mentira.
Isaías 53:9
Vagas

Vagas de Grails – Semana 1

Pessoal,

Vira e mexe vejo o pessoal perguntando sobre empresas que usam Grails, se existem vagas disponíveis no mercado, se vale a pena aprender. Para responder essas dúvidas, pretendo compilar algumas vagas disponíveis para desenvolvimento em Grails, ou que tenham Grails como pré-requisito, e publicá-las aqui semanalmente.

Inicialmente vou publicar vagas no Brasil, Estados Unidos, Espanha, Inglaterra e Portugal. Caso você se interesse em vagas em outros países, comente que incorporarei os países conforme demanda. Empresas que quiserem anunciar gratuitamente vagas para Grails podem entrar em contato pelo e-mail contato@vaidegrails.com.

Todas as vagas aqui foram anunciadas a menos de 7 dias, ou seja, ainda dá tempo de concorrer. Clique no nome título da vaga para ter acesso a um site com mais detalhes e poder fazer sua candidatura. Para dar início a essa nova seção semanal, essas foram as vagas escolhidas:

Brasil

Título e Descrição Cidade
Desenvolvedor(A) Java

Analise e design; Codificação; Implementação de testes unitários; Empacotamento e distribuição de produto

Habilidades esperadas:

Conhecimento com Framerwork Web (Spring MVC, Grails). Sólida experiência com Linguagem Java/JEE, Groovy, Javascript. Banco de dados Relacionais (Oracle, Postgres) Metodologias ágeis Scrum, XP, TDD. Tecnologias de Testes Automatizado, Ferramentas para Build e CI Maven, Hudson, Gradle. Servidor de aplicação Tomcat, Jetty ou Jboss. Sólidos conhecimentos orientação a objetos. Ferramentas de controle de versão GIT. Conhecimento em Frameworks de Front-End como AngularJS e ReactJS. Conhecimento em bancos de dados NoSQL como MongoDB. Familiaridade com ambientes Amazon AWS. Experiência na plataforma Java Web (J2EE); Experiência com a ferramenta de desenvolvimento Java;

Salario:
a combinar

Campinas – SP
Programador de sistemas

Irá desenvolver funcionalidades de acordo com as especificações técnicas pensando sempre na escalabilidade do software por conta da enorme quantidade de dados e crescimento rápido de usuários, desenvolver um código manutenível e bem estruturado em um ambiente colaborativo, codificação de acordo com as especificações técnicas, buscando sempre um código limpo e manutenível, construção de testes unitários, desenvolvimento orientado a testes, correção de BUGS de alta complexidade e realização de merges.

Beneficios

Vale Transporte; Vale Refeição; Assistência Médica; Seguro de vida; Participação nos lucros; Bolsa Escola/Faculdade; Assistência Odontológica; Estacionamento; Bolsa Pós-graduação / MBA;

Formação Acadêmica

Superior cursando ou completo na área de Sistemas.

Experiência

Experiência como programador de sistemas. Conhecimento avançado em linguagem JavaScript/JQuery, Spring, ferramentas de controle de versão (GIT), linguagem SQL, Tomcat e banco de dados Postgre. Desejável conhecimento em Grails.

Salário

De R$ 3.501,00 a R$ 4.000,00

 Joinville -SC
Desenvolvedor De Sistemas

Atuar com entendimento das especificações técnicas, execução dos desenvolvimentos, realização de testes de software e acompanhamento dos testes integrados. Monitorar tendências e tecnologias para contribuir com a melhoria de processos.Desenvolver sistemas utilizando tecnologia Grails.Conhecimento em banco de dados, desenvolvimento de APIs REST, Github e Scrum.Conhecimento em Spring, Redis, Elastic Search e AWS.

 São Paulo – SP
 Programador Java

Irá integrar o time responsável pelo desenvolvimento de um nova plataforma B2B. Codificar os aplicativos, prestar suporte e elaborar a documentação técnica.

Beneficios:

A Combinar

Formação Acadêmica:

Ensino Médio completo.

Experiência:

Experiência em Hibernate, Spring, WebServices BD, MySQL, Aplication, Server, Tomcat, Jetty, JavaScript / jQuery, HTML e CSS.Conhecimentos em Grails / Groovy, AWS, Elastic, Search, Git, OSX / Linux.

Salário:

De R$ 6.501,00 a R$ 7.000,00

São Paulo – SP

Estados Unidos

Título Cidade
 Java Developer

HR Solutions Start-up has an open job for a Senior Full-stack Java Engineer in downtown Oakland. Ideal candidates will have extensive experience building scalable cloud based applications with Java, significant integrations experience, and strong knowledge of front-end technologies. The company has built the first unified, cloud-based solution for HR, Benefits, and Payroll built on a single system architecture… and with significant venture capital this is the perfect opportunity forsomeone looking to work on a small team and have a huge impact in a growing company.

Required Skills &Experience

  • Expertise of Java J2EE
  • Knowledge or interest in Groovy & Grails (+)
  • Experience with Spring MVC and Hibernate
  • Very comfortable with Javascript, HTML, jQuery
  • BS (MS preferred) in Computer Science

Benefits & Perks

Competitive salary, full benefits, 401k, small and collaborative team, great career growth opportunity, opportunity to learn new technologies, flexible work schedule, and right off of 12th street BART.

Oakland – CA

Developer Enterprise Platform Engineering

Key Skills Required For The Job Are

  • Java-J2EE (Mandatory)
  • Groovy and Grails

As a Senior Developer, you are responsible for development, support, maintenance and implementation of a complex project module. You should have good experience in application of standard software development principles. You should be able to work as an independent team member, capable of applying judgment to plan and execute your tasks. You should have in-depth knowledge of at least one development technology/ programming language. You should be able to respond to technical queries / requests from team members and customers. You should be able to coach, guide and mentor junior members in the team.Minimum work experience:3 – 5 Years

Roles And Responsibilities“As a Senior Developer, you are responsible for development, support, maintenance and implementation of a complex project module. You should have good experience in application of standard software development principles. You should be able to work as an independent team member, capable of applying judgment to plan and execute your tasks. You should have in-depth knowledge of at least one development technology/ programming language. You should be able to respond to technical queries / requests from team members and customers. You should be able to coach, guide and mentor junior members in the team.”

Skill Description:Enterprise Platforms Engineering, HA-FT and Clustering, Cloud Engineering, Enterprise Platforms Engineering, English Language

We are an equal opportunity employer. We evaluate qualified applicants without regard to race, color, religion, sex, sexual orientation, gender identity, national origin, disability, veteran status, or any other protected characteristic. The EEO is the Law poster is available here.

VEVRAA Federal Contractor We Request Priority Protected Veteran and Disabled Referrals for all of our locations

Richfield – MN

Full-stack Java Developer

One of the first IOT companies located in Chicago that is a leading provider of data analytics for retail stores is hiring for a Java Contractor to help take their analytic products to the

cloud. You will be taking on some of the most challenging problems as they move to the cloud and enter the big data world. Their platform allows retail stores understand and see how effective and profitable they are doing by collecting and analyzing different data sets taken from their sensors. They are currently looking for someone that can work full stack with Java, Groovy on Grails and JavaScript.Required Skills

  • 3+ years of Core Java experience
  • Groovy on Grails is a plus
  • Ability to work full stack with JavaScript (MVC frameworks like Backbone, Angular, or React a plus)
  • Relational database knowledge (MySQL, PostgreSQL, etc)

Benefits

  • Greenfield development
  • Competitive salary
  • Full benefits
  • 401k, and many more
 Chicago – IL
Tech Architecture Delivery Specialist

Assess, design, implement and/or support world-class information technology architectures, for Accenture or our clients, spanning simple IT projects to large-scale, enterprise-level change programs.+Basic qualifications

1-3 years of experience in any of the following languages or technologies: Java, Groovy, Ruby, PHP, Python, JavaScript

1+ Years Of Application Design And Development Experience In One Or More Of The Following Areas

Responsive Design / HTML5 with experience in one of the following technologies – Backbone.js, AngularJS, Ember.js, Bootstrap

JVM-based languages and frameworks with experience in one of the following technologies – Grails, Play Framework

Functional Languages with experience in one of the following technologies – Scheme, Lisp, Haskell, Clojure, Scala, Erlang

Rapid development Web framework – Ruby on Rails, Django, Symfony, Laravel, Node.js (Express, Koa, etc)

Preferred Skills

Installation, configuration and development including work within a production environment

Experience designing and developing applications in an event-oriented, asynchronous fashion

Experience with ‘Web scale’ architecture design patterns and supporting infrastructure

Applicants for employment in the US must have work authorization that does not now or in the future require sponsorship of a visa for employment authorization in the United States and with Accenture (i.e., H1-B visa, F-1 visa (OPT), TN visa or any other non-immigrant status).

Candidates who are currently employed by a client of Accenture or an affiliated Accenture business may not be eligible for consideration.

Accenture is a Federal Contractor and an EEO and Affirmative Action Employer of Females/Minorities/Veterans/Individuals with Disabilities.

Equal Employment Opportunity

All employment decisions shall be made without regard to age, race, creed, color, religion, sex, national origin, ancestry, disability status, veteran status, sexual orientation, gender identity or expression, genetic information, marital status, citizenship status or any other basis as protected by federal, state, or local law.

Job candidates will not be obligated to disclose sealed or expunged records of conviction or arrest as part of the hiring process.

Accenture is committed to providing veteran employment opportunities to our service men and women.

Atlanta – GA

Espanha

Título Cidade
Senior Developer (J2Ee)

Essential Competences:

  • Senior J2EE developer background and experience
  • Minimum 8 year of programming
  • Advanced Analytics
  • Fluent in English and Spanish

An In-depth Knowledge Of And Quantifiable Working Experience With

  • Hibernate, Spring, Spring WebFlow, JSF, Grails
  • Html5, CSS 3, Bootstrap, Angular Material
  • Postgres, Mysql, MariaDB
  • Jboss, Tomcat, Apache
  • SVN, GitHub
  • PHP
  • Minimum 8 year of programming
  • Advanced Analytics
  • Fluent in English and Spanish

Knowledge of infrastructure (servers, continuous integration …)General Competencies (desirable requirements for success in this role)

  • Proactive, problem solving approach
  • Demonstration of professionalism with proficiency in interpersonal and communication skills
La Coruña

Programador Senior

Desarrollo de aplicaciones Web

Tecnologías: Java, groovy y grails

Base de datos: Oracle

 Madrid
Fullstack Developer

En Sopra Steria, multinacional francesa, estamos buscando un Fullstack developer que se responsabilizará del desarrollo de aplicaciones híbridas para ayudar a la mejora de servicio del departamento de IT. El stack tecnológico que nos gustaría que tuviese nuestro futuro compañero es:- Amplia experiencia desarrollando con JavaScript (patrones de diseño, buenas prácticas, uso de prototipos/herencia, módulos, AJAX, etc.).

– Experiencia con frameworks MVC en JavaScript (Angular, Backbone, Polymer, React…).- Construcción de SPA.- Construccion de web components.- Maquetación HTML5 y CSS3 (SASS/LESS/BOOSTRAP)

– Plantillas HTML: Underscore.js, Handlebar.js, etc.- Utilización de servicios REST/JSON.- Patrones de diseño MVC/MVP/MVVM.- Imprescindible experiencia en diseño e implementación de APIs con tecnología Rest- Java / Java EE: Spring (MVC, Data, etc.), JPA/Hibernate, SQL, AOP,XML, integración de procesos.- Desarrollo de web services: REST, SOAP, WSDL, Apache CXF, Apache Axis- JEE Servidores de Aplicaciones: JBoss AS, Oracle Weblogic.- Oracle, SQL y PL/SQL- Experiencia con Maven e Integración Continua: SVN-Maven-Hudson/ Jenkins- Patrones de diseño MVC/MVP/MVVPAdemás, sería un plus si cumple alguno de los siguientes requisitos (no obligatorios):

– Experiencia con otros framework JavaScript para desarrollo de aplicaciones Web: Spine.js, Knockout.js, Javascript MVC, Google Closure, Ember.js, Batman.js

– Valorable conocimientos de metodologías Agiles y herramientas de desarrollo rápido basados en Java (Grails, Spring Roo)- Conocimientos de Cloud Computing: AWS, Openstack, Openshift.- Experiencia demostrable en proyectos de dispositivos móviles utilizando tecnología híbridas- Análisis de requisitos, arquitecturas/diseños técnicos y desarrollo de aplicaciones para dispositivos móviles- Desarrollo de aplicaciones nativas para iOS y Android- Apache Cordova (PhoneGap)- Desarrollo con JavaScript usando BDD/TDD: js-test-driver, Sinon.js, Jasmine, QUnit, etc.- Patrones de diseño de usabilidad para dispositivos móviles iOS y Android.- TDD, BDD, Unit Testing, JUnit, Mockito, PowerMock, Selenium, Cucumber, Appium…- Metodologías ágiles como SCRUM y Kanban.Nuestros proyectos se desarrollan utilizando metodologías ágiles (SCRUM, Kanban) y avanzan gracias al trabajo en equipo de toda la comunidad que los hace suyos, viéndolos nacer y crecer. Si quieres desarrollar un proyecto y poder sentirlo tuyo, Sopra Steria es el lugar y te estamos esperando.

– Incorpórate a un equipo joven, actualizado a nivel tecnológico y con tus mismas inquietudes, donde puedas explotar tu potencial y se reconozca tu experiencia y conocimientos.

– Participa en proyectos innovadores que apuestan por tecnologías punteras y desarróllate dentro de Sopra.

– Aprende de tus compañeros y participa en nuestros programas de formación continua.

– Olvídate de las viejas formas de organización y trabaja con metodologías ágiles SCRUM y Kanban.

– Concilia tu vida profesional y personal con nuestros horarios flexibles.

– Disfruta de un contrato indefinido y salarios competitivos.

– Benefíciate de nuestros acuerdos sociales: seguro de vida, tickets restaurante, descuento en la contratación de un seguro médico privado…

Atrévete a trabajar de una forma distinta, ¡inscríbete y conócenos!

Madrid

Inglaterra

Título Cidade
Java Developer

Java, Apache, Spring, Groovy/ Grails, JenkinsWe require a strong Java Developer with at least 4 years of experience of Apache Camel, XML/XSLT, Maven, Spring and Git.Essential areas:-Experience in Continuous Delivery, Jenkins, Spring Integration. Desirable skills include IBM MQ, groovy, gradle. Ability to work independently with minimum supervision

Key Technologies

Java 7 / 8 Apache Camel Groovy / grails Spring Framework REST WS Maven, Git Gradle / Nexus / Sonarcube / Bitbucket JMS / AMQP / any MQ technologies Spock, jUnit, Mockito, Logback Linux, Tomcat 7 MySQL, Oracle

You Will Be Skilled At

Writing clean code Unit testing Restful web services Dependency management and injection ORM Frameworks Service orientated architecture, its advantages and disadvantages. Messaging Version Control

Please send your CV for immediate review.

Spring Technology is acting as an Employment Business in relation to this vacancy.Spring Technology is an Equal Opportunities employer; we welcome applicants from all backgrounds.

Milton Keynes
Java Developer

Java developer sought by forward looking and expanding company with growing online presence to develop and maintain their internal and external applications.As part of a dynamic department this is a fantastic opportunity to use the full range of Java skills, and take a proactive role in implementing new solutions and technologies.Working in an Agile environment the role offers the opportunity to be involved in the development and maintenance of current and new systems, both internal and directtocustomer.This role offers great potential for career progression, as well as an exciting opportunity to gain experience in a wide variety of Java technologies across complex and interesting applications. There is also the opportunity for direct liaison with users.Technical skills required are Java, Javascript, JSP, Struts, Hibernate , XML & Web Services including JSON, SOAP & RESTful, Grails, Groovy.You should have experience of working in an Agile environment.

The Primary Role Of The Java Developer Is

  • Make changes to existing applications as requested by business users
  • Develop new systems and solutions
  • Connect front end systems to back end processes and systems via APIs

General Responsibilities

  • Be able to manage own workload and work with minimal supervision
  • Provide estimates for own work
  • Do own unit testing & produce quality work
  • Work to and meet deadlines
  • Be responsible for delivering agreed assigned work to agreed dates
  • Be able to troubleshoot & provide solutions for issues
  • Liaise with other team members as required
  • Contribute to the technical direction of the Development Team
  • Mentor more junior developers as required
  • Provide documentation for systems as required
  • Contribute to the overall delivery quality and metrics of your team
  • An attention to detail, and willingness to take responsibility for all work and code produced
  • Ability to work independently

Previous Experience

  • Experience as a Java Developer in a commercial environment.
  • Experience working in Agile Environment
  • Background in Financial Services
  • Experience of tracking work in Jira
Manchester

Java Developer – Grails / Senior

Role Overview An experienced, senior Java Developer, with extensive Java, JavaScript, Grails and Groovy, is required by a leading business based in South West London. A salary of up to £60k is offered depending on experienceThe Senior Java Developer will responsible for the ongoing development and maintenance of Grails-based applications – looking at new functionality, integration projects and we services.Skills required The Senior Java Developer will ideally have the following experience / skills: – Education to degree level from a Russell Group University – ideally MSc / post grad level- Extensive commercial Java development experience- Solid Java, JavaScript, Grails, MySQL and Groovy skillsWho would the role suit? The role would suit an experienced Java Developer looking for their next challenge working with the latest technologies.Location South West LondonSalary / Benefits Up to £60k DOE

Londres

Portugal

Título Cidade

Groovy / Grails Developer – Porto e Aveiro

Dellent provides exciting and rewarding career opportunities. Applicants that adapt to change, handle competing priorities, and communicate effectively will thrive in Dellent’s fast-paced environment.We’re building a team for a new and exiting project in the field of health and safety based in Groovy / Grails technology. Responsibilities include delivering quality solutions through analyzing, coding, testing. Skills include test driven development, pair programming and re-factoring code. Candidate should possess solid communication skills and a strong desire to learn new technologies and development practices.Job Requirements

  • 2 years of Java Web/J2EE (unit testing, CI);
  • 2 years of GIT, Jenkins and Modern web development (HTML5, CCS3, jQuery);
  • 2 years of Groovy/Grails;
  • Experience with relational and document databases (SQL Server and/or MongoDB);
  • Willing to work in a Scrum team using Agile methodologies (standups, grooming, planning, retros);
  • Basic knowledge of design patterns is desired;
  • Ruby experience is desired.
Porto

Fullstack Web Developer (m/f)

A QiBit é a empresa especializada em Tecnologias de Informação e Comunicações pertencente à multinacional Gi Group.O nosso cliente é uma empresa de referência nacional que consolida mais de 50 anos de existência no mercado. Tendo vindo nas últimas duas décadas a apostar na criação de plataformas digitais e produtos multimédia como forma de diversificar a oferta e fortalecer o seu core business, procura reforçar a sua equipa do Porto com a integração de um Fullstack Web Developer (m/f).

Requisitos

  • Licenciatura em Informática ou áreas equivalentes;
  • Experiência profissional mínima de 4 anos em projetos de desenvolvimento, com maior predominância no desenvolvimento web;
  • Experiencia na análise e documentação de requisitos;
  • Desenho/modelação de software utilizando UML;
  • Conhecimentos sólidos no desenvolvimento orientado a objetos em PHP 5.6 ou superior utilizando frameworks MVC;
  • Conhecimentos Javascript, HTML 5, CSS 3;
  • Conhecimentos da arquitetura e desenvolvimento JEE, nomeadamente webservices, EJB components e Hibernate;
  • Domínio de SQL nomeadamente com bases de dados Oracle ou MySq;
  • Serão valorizados conhecimentos de Grails;

Oferta

  • Integração em equipa altamente especializada;
  • Oportunidade de integrar ambiente tecnológico de referência;
  • Pacote salarial ajustado às competências e ao potencial de evolução.
Aveiro
Java Software Developer

The engineering team in Viana do Castelo is responsible for building complex, high-scale, real-time systems, working closely with other parts of the business to support the marketing activities for our clients across Europe.

We are looking for a JAVA Developer professional with some working experience, with drive and enthusiasm to succeed in a demanding and team environment.

Main Responsabilities:

· Design, architect, test and implement features

· Build valuable tools to support the development process within our clients

· Deliver high quality and well-structured code

We are looking for someone with:

· Higher Education in Computer Engineering or equivalent

· Minimum 2-year of professional experience in Java

· Solid programming knowledge in OO

· Good knowledge of relational database SQL Server and MySQL

· Professional experience in JAVA, J2EE APIs (JMS, JDBC, Web Services) and Angular JS

· Ability to analyze and communicate with the customer

· Good communication skills and teamwork

· Ability to organize and prioritize tasks

· Good levels of spoken and written English

We also value knowledge in the following technologies (not mandatory):

· Grails

· Groovy

· GWT

Porto

Quem era ladrão não torne a roubar, antes trabalhe seriamente por realizar o bem com as suas próprias mãos, para ter com que socorrer os necessitados.
Efésios 4:28

Iniciante

Conexão com o banco de dados, mapeamento e GORM – Parte 1

Olá pessoal.

Os sistemas web normalmente precisam armazenar e ler informações de uma ou mais fontes de dados. Vamos imaginar por exemplo o Netflix. Esse sistema precisa ler de alguma fonte quais são os filmes/séries disponíveis para exibição, informações do usuário que está acessando, categorias de filmes/séries, quais são os mais acessados no momento, etc.

Além disso, precisa também gravar quais filmes já foram vistos pelo usuário, os perfis que o usuário cadastra, as informações de pagamento, etc. Diversas fontes de dados podem ser utilizadas, como arquivos presentes no(s) servidor(es) (como os vídeos) , outros sistemas (validação dos cartões de crédito utilizando webservices), bancos de dados (relacionais ou não-relacionais para armazenar o catálogo de vídeos e informações do usuário), ou qualquer outro tipo.

Sendo assim percebe-se a importância de conseguir acessar essas fontes de dados. De modo geral, é muito recorrente a leitura e armazenamento de informações em banco de dados, em especial os relacionais. Por isso, nessa série vamos ver como utilizar o Grails para ler e persistir informações em 3 diferentes bancos de dados relacionais: H2, PostgreSQL e MySQL. Outro ponto a ser abordado é como fica o mapeamento das nossas classes de domínio em tabelas do banco de dados, além dos métodos que o Grails já oferece para persistirmos e acessarmos facilmente os dados no banco, algo que é feito utilizando o GORM (Grails’ object relational mapping).

É importante mencionar que por padrão o Grails usa como base Hibernate para fazer o mapeamento das classes de domínio em tabelas do banco de dados. Por cima do Hibernate, está o GORM, que permite uma série de facilidades, como finders dinâmicos (um dos temas futuros dessa série). Bom, vamos ao que interessa!

Como pré-requisitos, você deve ter instalado:

  • Alguma versão 3.X do Grails, de preferência a 3.2.4 que é a que eu vou usar aqui. Se você não sabe como instalar o Grails, veja aqui.
  • O Docker (veja aqui como instalá-lo). O Docker será utilizado para rodarmos as imagens do PostgreSQL e do MySQL de modo bem mais prático. Todas as dicas aqui funcionam caso você já tenha um banco PostgreSQL ou MySQL, não precisa necessariamente usar o Docker, mas ai você precisa saber o nome do usuário, senha, nome do banco e host corretos para colocar nos lugares respectivos.

O primeiro passo será criar nossa aplicação, cujo nome muito original será Grailsflix :D. Basta usar o comando:

grails create-app grailsflix

Agora vamos criar duas classes de domínio bem simples, somente para vermos as tabelas criadas no banco de dados. A primeira terá o nome Categoria e a segunda Video. A relação entre elas pode ser vista no diagrama de classes a seguir:

Diagrama de classes do projeto GrailsFlix, com a relação entre a classe Categoria e a classe Video.
Diagrama de classes do projeto GrailsFlix, com a relação entre a classe Categoria e a classe Video.

Podemos ver pelo diagrama que a classe Categoria só terá o atributo nome, do tipo String. Para criar essa classse no Grails vamos usar o seguinte comando (dentro do diretório grailsflix que foi criado):

grails create-domain-class com.vaidegrails.grailsflix.Categoria

E vamos alterar o arquivo Categoria.groovy para que fique assim:

package com.vaidegrails.grailsflix

class Categoria {

    String nome
    
    static hasMany = [videos: Video]

    static constraints = {
    }
}

Você vai perceber que se rodar a aplicação nesse momento como grails run-app (ou grails r-a), vai receber um erro:

startup failed:
/home/bruno/git/vdg/grailsflix/grails-app/domain/com/vaidegrails/grailsflix/Categoria.groovy: 7: Apparent variable 'Video' was found in a static scope but doesn't refer to a local variable, static field or class. Possible causes:
You attempted to reference a variable in the binding or an instance variable from a static context.
You misspelled a classname or statically imported field. Please check the spelling.
You attempted to use a method 'Video' but left out brackets in a place not allowed by the grammar.
 @ line 7, column 31.
       static hasMany = [videos: Video]

Esse erro ocorre porque ainda não definimos a classe Video. O hasMany nesse caso serve para informar que uma categoria pode ter muitos filmes, ou seja, 0 ou mais vídeos (conforme a cardinalidade que definimos no diagrama de classes), e ele permite que “naveguemos” para os filmes de uma categoria.

Ou seja, quando tivermos um objeto da classe Categoria, basta acessar o atributo videos para obter a lista de vídeos dessa categoria. Mas para isso funcionar, vamos definir a classe vídeo com o seguinte comando:

grails create-domain-class com.vaidegrails.grailsflix.Video

E alterar a classe para que fique assim:

package com.vaidegrails.grailsflix

class Video {

    static belongsTo = [categoria: Categoria]

    String titulo
    Double duracao

    static constraints = {
    }
}

O belongsTo informa que um vídeo pertence a uma categoria, e implica que se removermos uma categoria do sistema, todos os vídeos daquela categoria serão removidos. Além disso, permite que a partir de um objeto da classe vídeo, acessemos a categoria dele por meio do atributo categoria.

Agora podemos rodar a aplicação (grails r-a) e abrir no navegador o endereço http://localhost:8080/. Podemos perceber que nossa aplicação já está rodando. Se acessarmos http://localhost:8080/dbconsole vamos ver uma tela assim:

Tela de conexão com o banco de dados.
Tela de conexão com o banco de dados.

Se clicarmos Connect, vamos ter acesso ao nosso banco de dados, já com as tabelas Categoria e Filme criadas (no canto superior esquerdo):

Conexão com o banco H2, com as tabelas já criadas.
Conexão com o banco H2, com as tabelas já criadas.

Mas calma aí…. Que banco é esse? Eu nem configurei nada de banco de dados, e já tenho acesso a um banco???

A resposta é SIM, você já tem acesso a um banco de dados. Quem criou para você foi o Grails! Ao rodar a sua aplicação, o Grails roda um banco chamado H2, que já está configurado no seu projeto. Não contente, o Grails ainda transforma suas classes de domínio em tabelas nesse banco.

Mas qual é o usuário e senha desse banco? Como eu descubro? Nesse caso, a resposta está no arquivo application.yml. Nele temos uma seção chamada dataSource (fonte de dados), a qual se encontra reproduzida a seguir:

dataSource:
    pooled: true
    jmxExport: true
    driverClassName: org.h2.Driver
    username: sa
    password:

environments:
    development:
        dataSource:
            dbCreate: create-drop
            url: jdbc:h2:mem:devDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE
    test:
        dataSource:
            dbCreate: update
            url: jdbc:h2:mem:testDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE
    production:
        dataSource:
            dbCreate: none
            url: jdbc:h2:./prodDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE
            properties:
                jmxEnabled: true
                initialSize: 5
                maxActive: 50
                minIdle: 5
                maxIdle: 25
                maxWait: 10000
                maxAge: 600000
                timeBetweenEvictionRunsMillis: 5000
                minEvictableIdleTimeMillis: 60000
                validationQuery: SELECT 1
                validationQueryTimeout: 3
                validationInterval: 15000
                testOnBorrow: true
                testWhileIdle: true
                testOnReturn: false
                jdbcInterceptors: ConnectionState
                defaultTransactionIsolation: 2 # TRANSACTION_READ_COMMITTED

Logo no começo temos as seguintes propriedades definidas:

    driverClassName: org.h2.Driver
    username: sa
    password:

O driverClassName define o nome do driver utilizado para a conexão com o banco de dados. Como o Grails por padrão usa o banco H2, então a configuração informa que vamos utilizar o driver org.h2.Driver. O username e password definem respectivamente o nome de usuário e a senha que vamos utilizar para conectar com o nosso banco, no caso sa para o usuário, e a senha vazia, ou seja, sem senha.

Depois temos a seção environment, com três subseções (development, test e production) que definem como nosso banco será configurado em cada um desses ambientes. Observe que ao rodar o grails r-a, entramos no ambiente development. Nesse ambiente temos essas configurações:

    dbCreate: create-drop
    url: jdbc:h2:mem:devDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE

O dbCreate pode receber esses valores:

  • create-drop – cria todas as tabelas do banco ao iniciar a aplicação, e apaga todas elas ao finalizar a aplicação.
  • create – somente cria todas as tabelas do banco ao iniciar a aplicação, sem apagá-las ao final.
  • update – verifica se as tabelas disponíveis no banco de dados estão coerentes com as classes de domínio, e se não estiverem, tenta aplicar as alterações necessárias.
  • validate – valida se as tabelas disponíveis no banco de dados estão coerentes com as classes de domínio e caso não estejam, impede que a aplicação suba.

Como estamos começando a desenvolver ainda, e não temos dados verdadeiros no banco, é interessante manter o create-drop, para que sempre o banco seja apagado e recriado corretamente. Com o passar do tempo podemos mudar essa configuração para update. Em produção é recomendável utilizar o validate, e usar outros modos de alterar o banco, como por exemplo usando o Flyway.

Bom, eu tinha mencionado que ia ensinar como conectar no H2, PostgreSQL e MySQL, mas o Grails já estragou a brincadeira e deu de graça a conexão no H2. Vamos então alterar nossa aplicação para conectar a um banco de dados PostgreSQL. Mas para isso, vamos primeiro usar o Docker para rodar uma instância do PostgreSQL na nossa máquina. O repositório da imagem Docker oficial do PostgreSQL pode ser acessado aqui. Podemos rodar essa imagem com o seguinte comando:

docker run -p 5432:5432 –name postgres -e POSTGRES_USER=vdg -e POSTGRES_PASSWORD=vdg -e POSTGRES_DB=grailsflix -d postgres:9.5

O comando docker run roda uma imagem (postgres:9.5), e podemos passar parâmetros para ele. A lista dos parâmetros usados no comando apresentado com suas respectivas descrições encontra-se a seguir:

  • -p 5432:5432: Com esse parâmetro linkamos a nossa porta 5432 com a porta 5432 do container do PostgreSQL . Se por acaso sua porta 5432 estiver ocupada, você pode linkar outra porta sua na porta 5432 (porta padrão do PostgreSQL), por exemplo a porta 7777 (-p 7777:5432).
  • –name postgres: Define o nome PostgreSQL para container.
  • -e POSTGRES_USER=vdg): Define que vamos criar e utilizar o usuário vdg (de Vai de Grails :D)
  • -e POSTGRES_PASSWORD=vdg: Define que a senha do usuário criado com o parâmetro anterior será vdg.
  • -d: Indica que vamos rodar em modo detached, ou seja, quando o processo raiz utilizado para rodar o container for finalizado, o container será finalizado.
  • -POSTGRES_DB=grailsflix: Define o nome do nosso banco de dados, no caso grailsflix.

Uma vez que o PostgreSQL já está rodando, vamos alterar nossa aplicação para que ela acesse esse banco. Primeiro alteramos o arquivo build.gradle, acrescentando a dependência do driver do PostgreSQL (em negrito) na seção dependencies:

dependencies {
    compile "org.springframework.boot:spring-boot-starter-logging"
    compile "org.springframework.boot:spring-boot-autoconfigure"
    compile "org.grails:grails-core"
    compile "org.springframework.boot:spring-boot-starter-actuator"
    compile "org.springframework.boot:spring-boot-starter-tomcat"
    compile "org.grails:grails-dependencies"
    compile "org.grails:grails-web-boot"
    compile "org.grails.plugins:cache"
    compile "org.grails.plugins:scaffolding"
    compile "org.grails.plugins:hibernate5"
    compile "org.hibernate:hibernate-core:5.1.2.Final"
    compile "org.hibernate:hibernate-ehcache:5.1.2.Final"
    console "org.grails:grails-console"
    profile "org.grails.profiles:web"
    runtime "com.bertramlabs.plugins:asset-pipeline-grails:2.11.6"
    runtime "com.h2database:h2"
    testCompile "org.grails:grails-plugin-testing"
    testCompile "org.grails.plugins:geb"
    testRuntime "org.seleniumhq.selenium:selenium-htmlunit-driver:2.47.1"
    testRuntime "net.sourceforge.htmlunit:htmlunit:2.18"
    runtime 'org.postgresql:postgresql:9.4-1201-jdbc41'
}

Agora vamos alterar o arquivo application.yml com as informações referentes ao PostgreSQL:

dataSource:
    pooled: true
    jmxExport: true
    driverClassName: org.postgresql.Driver
    username: vdg
    password: vdg

environments:
    development:
        dataSource:
            dbCreate: create-drop
            url: jdbc:postgresql://localhost:5432/grailsflix           

E rodamos novamente nossa aplicação. Vamos novamente em http://localhost:8080/dbconsole

Agora teremos que selecionar Generic PostgreSQL em Saved Settings e colocar as seguintes informações:

Driver Class: org.postgresql.Driver

JDBC URL: jdbc:postgresql://localhost:5432/grailsflix

User Name: vdg

Password: vdg

Ao clicar em Connect, vamos conectar no nosso banco de dados PostgreSQL., conforme vemos na imagem a seguir:

DB Console conectado em banco de dados PostgreSQL.
DB Console conectado em banco de dados PostgreSQL.

O modo de conexão no MySQL é muito semelhante ao PostgreSQL, por isso serei mais sucintos nas explicações dele. A imagem Docker oficial dele fica aqui. Para rodá-la usamos esse comando:

docker run -p 3306:3306 –name mysql -e MYSQL_USER=vdg -e MYSQL_PASSWORD=vdg -e MYSQL_DATABASE=grailsflix -e MYSQL_ROOT_PASSWORD=password -d mysql:5.7

Os parâmetros MYSQL_USER e MYSQL_PASSWORD definem um novo usuário (o qual vamos usar para acessar a base) e a sua senha. Já o parâmetro MYSQL_DATABASE define o nome da nossa base, e que o usuário que criamos vai ter total acesso. O parâmetro MYSQL_ROOT_PASSWORD define a senha do usuário root.

Como vocês já devem ter percebido, devemos colocar a dependência do driver para conexão com o MySQL. Portanto, vamos deixar a seção dependencies do nosso arquivo build.gradle assim:

dependencies {
    compile "org.springframework.boot:spring-boot-starter-logging"
    compile "org.springframework.boot:spring-boot-autoconfigure"
    compile "org.grails:grails-core"
    compile "org.springframework.boot:spring-boot-starter-actuator"
    compile "org.springframework.boot:spring-boot-starter-tomcat"
    compile "org.grails:grails-dependencies"
    compile "org.grails:grails-web-boot"
    compile "org.grails.plugins:cache"
    compile "org.grails.plugins:scaffolding"
    compile "org.grails.plugins:hibernate5"
    compile "org.hibernate:hibernate-core:5.1.2.Final"
    compile "org.hibernate:hibernate-ehcache:5.1.2.Final"
    console "org.grails:grails-console"
    profile "org.grails.profiles:web"
    runtime "com.bertramlabs.plugins:asset-pipeline-grails:2.11.6"
    runtime "com.h2database:h2"
    testCompile "org.grails:grails-plugin-testing"
    testCompile "org.grails.plugins:geb"
    testRuntime "org.seleniumhq.selenium:selenium-htmlunit-driver:2.47.1"
    testRuntime "net.sourceforge.htmlunit:htmlunit:2.18"
//    runtime 'org.postgresql:postgresql:9.4-1201-jdbc41'
    runtime 'mysql:mysql-connector-java:5.1.36'
}

Percebam que coloquei o driver do MySQL e comentei o do PostgreSQL, uma vez que não é mais necessário. Mas você poderia, caso quisesse, por exemplo, usar o banco PostgreSQL para ambiente de desenvolvimento, e o MySQL para produção (apesar de eu não recomendar). Nesse caso, você manteria os dois drivers (descomentados) no seu build.gradle.

Cabe ressaltar que não mexemos na dependência do H2 (runtime “com.h2database:h2”) pois ela está configurada tanto para testes quanto para produção. Do mesmo modo, se não formos usar o H2 em nenhum ambiente, podemos comentá-la ou removê-la desse arquivo.

Agora precisamos definir as configurações para acesso ao MySQL no arquivo application.yml:

dataSource:
    pooled: true
    jmxExport: true
    driverClassName: com.mysql.jdbc.Driver
    dialect: org.hibernate.dialect.MySQL5InnoDBDialect
    username: vdg
    password: vdg

environments:
    development:
        dataSource:
            dbCreate: create-drop
            url: jdbc:mysql://localhost:3306/grailsflix

Definimos o driver (com.mysql.jdbc.Driver), o usuário e a senha (ambos vdg), a url (jdbc:mysql://localhost:3306/grailsflix), e agora definimos também um dialeto (dialect: org.hibernate.dialect.MySQL5InnoDBDialect). O dialeto é utilizado pelo Hibernate para gerar os SQLS apropriados para cada tipo de banco de dados. Poderíamos ter definido um dialeto para a conexão com o PostgreSQL também. Nesse link, temos uma lista de dialetos dos principais bancos de dados suportados pelo Hibernate.

Bom rodando nossa aplicação e entrando no DB Console, teremos que selecionar Generic MySQL em Saved Settings e colocar as seguintes informações:

Driver Class: com.mysql.jdbc.Driver

JDBC URL: jdbc:mysql://localhost:3306/grailsflix

User Name: vdg

Password: vdg

Ao clicar em Connect, vamos ver que estamos acessando um banco MySQL, conforme a figura a seguir:

DB Console conectado em banco de dados MySQL.
DB Console conectado em banco de dados MySQL.

Por hoje, vimos como é fácil configurar a conexão do banco de dados relacionais no Grails. Com algumas poucas linhas alteradas, deixamos de usar o H2, e passamos a usar o PostgreSQL, e depois o MySQL! Se você quiser, pode obter o código dessa aplicação de exemplo aqui.

Nos próximos posts da série, vamos ver como inserir e ler informações nas tabelas, bem como dar uma analisada no jeito que o Grails mapeia nossas classes de domínio no banco de dados! Espero que tenham gostado, e até a próxima!

Vai, ó preguiçoso, ter com a formiga, observa seu proceder e torna-te sábio:
ela não tem chefe, nem inspetor, nem mestre;
prepara no verão sua provisão, apanha no tempo da ceifa sua comida.
Provérbios 6:6-8
Vagas

Canal da Peça busca desenvolvedor Grails

Olá pessoal.

Hoje o post vai ser bem curtinho, somente para repassar uma vaga de desenvolvedor Grails. A empresa que oferece a vaga é a Canal da Peça, localizada em São Paulo.

Veja a descrição da vaga neste link.

Quem souber de vagas abertas de Grails, me informe pelos comentários, que colocarei aqui em futuros posts!

Obrigado!

Quando ainda estávamos com vocês, nós lhes ordenamos isto: se alguém não quiser trabalhar, também não coma.
Pois ouvimos que alguns de vocês estão ociosos; não trabalham, mas andam se intrometendo na vida alheia.
A tais pessoas ordenamos e exortamos no Senhor Jesus Cristo que trabalhem tranqüilamente e comam o seu próprio pão.
2 Tessalonicenses 3:10-12
Divulgações

Vagas no curso de Desenvolvimento de Software para a Web na UFSCar

Olá pessoal!

Hoje passei para comunicar a vocês que a Universidade Federal de São Carlos está oferecendo nova turma para o Curso de Pós-Graduação “Lato-Sensu” em Desenvolvimento de Software para a Web, indicado a profissionais de mercado da área de desenvolvimento de software e que sejam portadores de diploma de curso superior.

As aulas serão realizadas as sextas feiras a noite e aos sábados pela manhã, de acordo com o calendário letivo, no Departamento de Computação da Universidade Federal de São Carlos. São disponibilizadas 40 vagas.

O curso é bastante interessante, composto de módulos que abordam temas bem relevantes como desenvolvimento ágil de software, segurança e teste de software. Cabe destacar o módulo Desenvolvimento de Software com Grails, o qual será ministrado pelos professores Antonio Francisco do Prado, Ivan João Foschini, Rafael Tomé de Souza e por mim, que visa apresentar o desenvolvimento de aplicações para a Web usando o framework Grails.

Como vocês já devem ter visto aqui no blog :D, o Grails permite uma alta produtividade e roda na JVM (Java Virtual Machine), permitindo sua execução em diversos ambientes computacionais diferentes. Além disso, é full-stack, ou seja, permite fazer facilmente a integração da aplicação com o banco de dados, desenvolvimento das classes de domínio, criação de services, controllers, e páginas web. Todos essas fases serão aprendidas durante o módulo, tornado o aluno apto a desenvolver aplicações completas!

Se você ficou interessado, a inscrição para o curso pode ser feita pessoalmente na Secretaria de Extensão no Departamento de Computação da UFSCar ou submetidas de forma eletrônica pelo site do curso, observando a data limite de 30 de janeiro de 2017. As aulas iniciarão em 10 de março de 2017.

Informações adicionais podem ser obtidas no site, por envio de mensagem ao e-mail latosensu@dc.ufscar.br, ou pelo telefone da Secretaria de Extensão: (16) 3351-9494 (das 8h as 12h – de segunda a sexta, com Rosana).

Esse curso na UFSCar é muito bom e eu recomendo fortemente. Eu fiz ele no período de 2010-2011, e ele que motivou a entrar de vez no mundo do desenvolvimento para a web!

Aguardo vocês lá! Abraços.

Tudo o que fizerdes, fazei-o de bom coração, como para o Senhor e não para os homens, certos de que recebereis, como recompensa, a herança das mãos do Senhor. Servi a Cristo, Senhor.
Colossenses 3:23,24