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
Iniciante

Achei um bug no Grails… E gostei!

Olá pessoal.

Hoje vou falar sobre um fato curioso. Recentemente realizei minha primeira colaboração (ainda que BEM singela) para a comunidade Grails. Encontrei um bug no Grails! Vou explicar como foi todo o processo. Tudo começou quando eu estava fazendo alguns testes com a versão 3.2.3 do Grails, e me deparei com um comportamento estranho. Eu tinha a seguinte classe de domínio:

class TestDomain {
    String aString
    Integer aNumber
    Date aDate

    static constraints = {
    }
}

Era uma classe bem simples, para fins didáticos, composta de um atributo do tipo String (aString), um inteiro (aNumber) e uma data (aDate). Como vocês podem notar, eu não defini nenhuma constraint, sendo assim, o padrão do Grails é considerar que todos os campos devem ser não-nulos, ou seja, não devem aceitar atributos nulos na hora de validar ou fazer a persistência dos dados.

Eu queria refletir exatamente isso, por isso criei o seguinte teste:

@TestFor(TestDomain)
class TestDomainSpec extends Specification {

    def setup() {
    }

    def cleanup() {
    }

    void "An empty instance should not be saved"() {
        when:
        new TestDomain().save(failOnError: true, flush: true)
        then:
        true
    }
}

Notem que eu quis avaliar o caso em que uma instância vazia, ou seja, com atributos nulos, não deve ser salva (“An empty instance should not be saved”).

Para isso, criei um bloco when para definir caso que eu queria testar. Nesse bloco especifiquei que eu quero criar uma instância da classe TestDomain (new TestDomain()) e chamar o método save, manifestando que desejo que seja lançada uma exceção caso a instância não seja válida (failOnError: true), e que a persistência seja feita imediatamente (flush:true).

No bloco then, que é o bloco onde você deve especificar o que espera que aconteça, eu coloquei true. Você deve se perguntar por que eu fiz isso. Na verdade, eu coloquei true só para completar o bloco then. Eu queria ver o teste falhar, pois eu esperava que a exceção fosse lançada, dadas as restrições não atendidas. Uma vez que ele falhasse, iria complementar o teste do modo correto.

No entanto, para a minha surpresa, o teste não falhou!!! Ou seja, nenhuma exceção foi lançada, mesmo os atributos estando nulos. Achei muito estranho, e por isso resolvi abrir uma issue no projeto grails-core que está no Github.

Ao clicar em New Issue, é apresentado um modelo de como relatar uma nova issue, o qual reproduzo aqui:

Thanks for reporting an issue for Grails framework, please review the task list below before submitting the
issue. Your issue report will be closed if the issue is incomplete and the below tasks not completed.

NOTE: If you are unsure about something and the issue is more of a question a better place to ask questions is on Stack Overflow (http://stackoverflow.com/tags/grails) or Slack (http://slack-signup.grails.org). DO NOT use the issue tracker to ask questions.

### Task List

– [ ] Steps to reproduce provided
– [ ] Stacktrace (if present) provided
– [ ] Example that reproduces the problem uploaded to Github
– [ ] Full description of the issue provided (see below)

### Steps to Reproduce

1. TODO
2. TODO
3. TODO

### Expected Behaviour

Tell us what should happen

### Actual Behaviour

Tell us what happens instead

### Environment Information

– **Operating System**: TODO
– **Grails Version:** TODO
– **JDK Version:** TODO
– **Container Version (If Applicable):** TODO

### Example Application

– TODO: link to github repository with example that reproduces the issue

Como podemos ver, é necessário colocar os passos para reproduzir o problema, o comportamento esperado, o comportamento atual (errado), informações do ambiente e um link para uma aplicação de exemplo no Github.

Seguindo essas diretrizes, abri a issue número 10343, que pode ser vista nesse link. Eu então submeti meu código no Github, mostrando o problema que eu havia encontrado. Desse modo, fica mais fácil para os desenvolvedores do Grails conseguirem reproduzir o erro e corrigí-lo. O código está disponível aqui.

Eu abri a issue no dia 04/12/2016, e já no dia 05/12/2016 recebi uma resposta do Jeff Brown, um dos mais famosos membros da equipe do Grails. Além de ele indicar qual seria o possível problema, que era o processamento camel case de atributos que começam com apenas uma letra minúscula (caso de todos os nomes de atributos que utilizei), ainda ele me deu dicas de como refinar meu teste :).

A correção desse pequeno bug foi feita e incorporada na versão 3.2.4 do Grails, lançada no dia 21/12/2016, juntamente com outras correções. Ou seja, entre eu relatar o bug, e ele ser corrigido definitivamente, foram 17 dias, um tempo que eu considero perfeitamente aceitável!

Outro fatores que me marcaram foi a facilidade no modo de registrar o bug, já com a existência de um modelo, e a atenção da equipe em relação à minha solicitação. Isso só me fez ter a certeza de que a comunidade Grails é bem receptiva e atuante. Uma equipe de ótimos profissionais está atenta ao registro de bugs e novas funcionalidades, e trabalhará o mais rápido possível para atender as demandas.

Por todos esses motivos, posso dizer que apesar de achar um (pequeno) bug no Grails, eu gostei!  Gostei por saber que não estamos sozinhos, e que nosso  grande framework está em constante evolução, se tornando cada vez mais estável e flexível.

Sendo assim, se você encontrar um erro no Grails, ou se quiser uma nova funcionalidade, faça como eu. Não tenha vergonha e abra uma issue mostrando exatamente o que você quer/precisa. Com certeza você será bem recebido, e vai colaborar bastante (ou um pouquinho) nesse processo de evolução do Grails.

Essa é a grande força dos projetos open source: a colaboração. E é por isso que eu recomendo e indico a todos não só o Grails, mas como qualquer outro framework, programa ou ferramenta open source!

Mas existem muitas outras formas de colaborar com a comunidade! Pode corrigir os problemas encontrados pelos outros membros da comunidade baixando e corrigindo o código fonte, fazer/responder perguntas no StackOverflow, debater no Slack ou na lista de discussão, acompanhar novidades no Twitter, participar de eventos e conferências, fazer contatos profissionais no nosso grupo no Linkedin, ou aprender pequenos truques no Vai de Grails!

Enfim, você não está sozinho nessa jornada pelo mundo Grails! A comunidade é muito ativa, e vai te fornecer todo o auxílio necessário. Até a próxima pessoal, e já sabem. Fiquem a vontade para entrar em contato sobre qualquer coisa relacionada a Grails. Abraços.

 

O preguiçoso diz: “Lá está um leão no caminho, um leão feroz rugindo nas ruas! “
Como a porta gira em suas dobradiças, assim o preguiçoso se revira em sua cama.
O preguiçoso coloca a mão no prato, mas acha difícil demais levá-la de volta à boca.
O preguiçoso considera-se mais sábio do que sete homens que respondem com bom senso.
Provérbios 26:13-16
Iniciante

Empacotando sua aplicação Grails

Pessoal,

Hoje vim trazer uma dica bem fácil para vocês. Um modo de empacotar, distribuir e implantar sua aplicação WEB é por meio de um arquivo WAR. O WAR (Web Application Archive) é um arquivo que pode ser implantado (deploy) em servidores compatíveis com Java EE, e que contém os arquivos compilados da sua aplicação WEB.

Ou seja, ele é um modo padronizado de empacotar, distribuir e implantar sua aplicação em servidores WEB. Caso queira ler mais sobre WAR, sugiro esse link. Sendo assim, é claro que os desenvolvedores do Grails pensaram em um modo fácil de você poder gerar um WAR da sua aplicação. Para isso basta executar o comando war do Grails, cuja documentação, para a versão 3.2.2 do Grails, pode ser vista aqui.

Esse comando tem a seguinte sintaxe:

grails ambiente war

Por padrão o ambiente é prod (produção), mas você também pode substituir o por dev ou test. Ao executar esse comando, um arquivo war é gerado dentro do diretório build/libs, da sua aplicação. Por exemplo, se eu criar uma aplicação com o nome minhaAplicacao, dentro do diretório do meu usuário (/home/bruno), entrar no diretório dela (/home/bruno/minhaAplicacao), e executar o comando:

grails war

Um arquivo é gerado dentro do diretório /home/bruno/minhaAplicacao/build/libs. O arquivo gerado tem o seguinte formato de nome:

nome_aplicacao-versao_aplicacao.war

No exemplo que citei, o arquivo teria o seguinte nome:

minhaAplicacao-0.1.war

Uma vez que a versão inicial da aplicação recém-criada é 0.1. Para ter certeza disso, você pode alterar o seu arquivo build.gradle, alterando o version para:

version "0.2"

Ao rodar novamente o comando grails war, o arquivo minhaAplicacao-0.2.war será gerado no diretório build/libs.

Ok, legal, já conseguimos gerar nosso war. Mas e se quisermos mudar o nome dele, para vai_de_grails.war, independente da versão da nossa aplicação. Podemos fazer isso acrescentando uma clousure war, e definindo o archiveName com nome do arquivo que queremos no arquivo build.gradle. Desse modo, essa clousure ficará assim:

war {
   archiveName = "vai_de_grails.war"
}

Agora independente da versão da nossa aplicação, sempre o nome do arquivo será vai_de_grails.war.

Mas e se quisermos alterar também a localização do arquivo war gerado? Por exemplo, criá-lo dentro do diretório dist da nossa aplicação (que ainda não existe). Fácil, basta definir o destinationDir dentro da clousure war:

war {
   archiveName = "vai_de_grails.war"
   destinationDir = new File("/home/bruno/minhaAplicacao/dist")
}

Observe que agora tivemos que passar um arquivo (File) como parâmetro. Note que passamos o caminho completo da nossa aplicação: /home/bruno/minhaAplicacao. Isso é muito feio, uma vez que se outro usuário baixar nosso projeto, provavelmente ele não terá um usuário com o mesmo nome que o nosso. Um modo de resolver isso é usar as variáveis de sistema inicializadas pelo Grails. Podemos então trocar o destinatioDir para:

war {
   archiveName = "vai_de_grails.war"
   destinationDir = new File("${System.properties.getProperty("base.dir")}/dist")
}

Desse modo, agora não importa mais onde nossa aplicação esteja localizada. Vamos sempre obter o caminho completo para ela usando a propriedade base.dir, com o comando ${System.properties.getProperty(“base.dir”)}.

Outro modo é simplesmente definir um caminho relativo ao diretório da nossa aplicação:

war {
   archiveName = "vai_de_grails.war"
   destinationDir = new File("dist")
}

Outro recurso interessante é utilizar variáveis que são definidas no próprio build.gradle. A variável version que alteramos ao longo desse post pode ser utilizada caso queiramos que nosso arquivo seja nomeado vai_de_grails-versao_aplicacao.war, desse modo:

war {
   archiveName = "vai_de_grails-${version}.war"
   destinationDir = new File("dist")
}

Espero que tenha ficado claro a flexibilidade do comando grails war. Temos um controle completo sobre o local e o nome do arquivo war gerado por ele. Ele é bastante útil para por exemplo fazer o deploy da nossa aplicação no Tomcat, ou qualquer outro servidor web. Dentro do arquivo build.gradle conseguimos utilizar variáveis definidas por nós mesmos, variáveis iniciadas pelo Grails e podemos até chumbar valores.

Em posts futuros pretendo mostrar como implantar o war gerado em uma instância do Tomcat, e novos modos de rodar nossa aplicação como um serviço. Qualquer dúvida, ou sugestão fiquem a vontade para comentar! Abraços e até a próxima.

“Porque Deus tanto amou o mundo que deu o seu Filho Unigênito, para que todo o que nele crer não pereça, mas tenha a vida eterna.
João 3:16