Usando classes Java em Grails

Question

Eu tenho um aplicativo Java \ Primavera \ Hibernate - completa com classes de domínio que são basicamente Hibernate POJOs

Há um pedaço de funcionalidade que eu acho que pode ser escrito bem em Grails.

Eu gostaria de reutilizar as classes de domínio que eu criei no principal aplicativo Java

O que é a melhor maneira de fazê-lo?

Devo escrever novas classes de domínio estendendo as classes Java? este brega sons Ou Can I 'gerar' controladores de fora das classes de domínio Java?

Quais são as melhores práticas em torno reutilização de objetos de domínio Java em Grails \ Groovy Estou certo de que deve haver outros que escrevem algumas peças em Grails \ Groovy

Se você sabe sobre um tutorial que fala sobre uma tal Integração- que seria fantástico !!!

PS: Estou muito um novato em grails-Groovy assim pode estar faltando o óbvio. Thanks !!!

Answer 1

Você realmente quer / necessidade de usar Grails em vez de apenas Groovy?

Grails realmente não é algo que você pode usar para adicionar uma parte para um aplicativo web existente. A "Convenção sobre configuração" meios abordagem totalmente que você praticamente tem que jogar pelas regras Grails', caso contrário, não há nenhum ponto em usá-lo. E uma dessas regras é que objetos de domínio são classes Groovy que são fortemente "reforçada" pelo tempo de execução Grails.

Pode ser possível para tê-los estender as classes Java existentes, mas eu não apostaria nisso - e todas as partes Spring e Hibernate do seu aplicativo existente teria que ser descartado, ou pelo menos você tem que gastar um grande esforço para torná-los trabalhar em Grails. Você estará lutando o quadro em vez de lucrar com isso.

IMO você tem duas opções:

• Reescreva a sua aplicação a partir do zero em Grails enquanto reutilizar o máximo de código existente possível.
• Mantenha seu aplicativo como ele é e adiciono o material novo em Groovy, sem usar Grails.

O último é provavelmente melhor na sua situação. Grails se destina a criar novas aplicações web muito rapidamente, que é onde ele brilha. Adicionando material para uma aplicação existente não é apenas o que foi feito.

EDIT: Quanto ao esclarecimento nos comentários: Se você está planejando para escrever basicamente um / frontend manutenção entrada de dados para dados usados ??por outro aplicativo e ter a DB como o único canal de comunicação entre eles, que possa realmente funcionar muito bem com Grails; certamente pode ser configurado para usar um esquema DB existente em vez de criar seu próprio das classes de domínio (embora este último é menos trabalho).

Answer 2

Sabendo o quão bem Groovy e Grails excel a integração com o código Java existente, eu acho que eu poderia ser um pouco mais otimista do que Michael sobre suas opções.

A primeira coisa é que você já está usando Spring e Hibernate, e desde suas classes de domínio já estão POJOs que deve ser fácil de integrar. Quaisquer Spring beans que você pode ter pode ser especificado em um arquivo XML, como de costume (em grails-app/conf/spring/resources.xml) ou muito mais simples usando o bean Spring construtor característica do Grails. Eles podem então ser acessado por nome em qualquer controlador, vista, serviço, etc, e trabalhou com as usual.

Aqui estão as opções, como eu vê-los, para a integração de suas classes de domínio e de esquema de banco de dados:

• Bypass GORM e Carregar / Salvar seu domínio objetos exatamente como você já está fazendo.

  Grails não forçá-lo a usar GORM, por isso deve ser bastante simples: criar um .jar do seu código Java (se já não o fez) e soltá-lo no diretório lib do Grails aplicativo. Se o seu projeto Java é Mavenized, é ainda mais fácil:. Grails 1.1 funciona com Maven, para que possa criar uma pom.xml para o seu Grails aplicativo e adicione seu projeto Java como uma dependência como você faria em qualquer outro projeto (Java)

  De qualquer forma, você será capaz de import suas classes (e quaisquer classes de suporte) e prossiga como de costume. Por causa da forte integração do Groovy com Java, você vai ser capaz de criar objetos, carregá-los a partir do banco de dados, modificá-los, salvá-los, validá-los etc. exatamente como você faria em seu projeto Java. Você não terá todas as conveniências de GORM desta maneira, mas você teria a vantagem de trabalhar com seus objetos de uma forma que já faz sentido para você (exceto, talvez, com um pouco menos de código graças ao Groovy). Você pode sempre tentar essa opção primeiro a obter algo de trabalho, então considerar uma das outras opções mais tarde, se parece fazer sentido naquele momento.

  Uma dica, se você tentar fazer essa opção: resumo do código de persistência real em um serviço Grails (StorageService talvez) e ter seus controladores chamar métodos em que, em vez de lidar com persistência diretamente. Desta forma, você pode substituir esse serviço com outra coisa na estrada, se necessário, e, enquanto você manter a mesma interface de seus controladores não serão afetados.

• Criar novas classes de domínio Grails como subclasses de suas classes Java existentes.

  Isto pode ser bastante simples, se as aulas já são escritos como feijão adequadas, ou seja com métodos getter / setter para todas as suas propriedades. Grails verá essas propriedades herdadas como seria se eles foram escritos no estilo simples Groovy. Você vai ser capaz de especificar como validar cada propriedade, usando verificações de validação simples (não nulo, e não em branco, etc.) ou com fechos que fazer as coisas mais complicadas, talvez chamando métodos existentes em suas superclasses POJO.

  Você vai precisar quase de certeza de ajustar os mapeamentos por meio do GORM mapeamento DSL para se adequar às realidades de seu esquema de banco de dados existente. Relações estaria onde pode ficar complicado. Por exemplo, você pode ter alguma outra solução, onde GORM espera uma junção mesa, embora pode até haver uma maneira de contornar as diferenças como estas. Eu sugiro aprender o máximo que puder sobre GORM e seu DSL mapeamento e, em seguida, experimentar com algumas de suas classes para ver se esta é uma opção viável.

• Have Grails usar seus POJOs existentes e mapeamentos do Hibernate diretamente.

  Eu não tentei isso mesmo, mas de acordo com Hibernate Integração página do Grails isto é suposto ser possível: "Grails também permite que você escreva seu modelo de domínio em Java ou re-utilizar um fazer existenteprincipal modelo que foi mapeado usando o Hibernate. Tudo que você tem a fazer é colocar o arquivo necessário 'hibernate.cfg.xml' e correspondentes arquivos de mapeamentos no '% PROJECT_HOME% / grails-app / conf / hibernação' diretório. Você ainda será capaz de chamar todos os métodos persistentes e consulta dinâmica permitidos em GORM! "

  pesquisando "gorm legacy" aparece uma série de discussões úteis e exemplos, por exemplo este post por Glen Smith (co-autor do logo-a-ser-lançado Grails em Action ), onde ele mostra um arquivo de mapeamento Hibernate usado para integrar-se com "o legado DB do inferno". Grails em Ação tem um capítulo intitulado "Advanced GORM Kungfu" que promete uma discussão detalhada sobre este tema. Eu tenho um PDF pré-lançamento do livro, e enquanto eu não ter chegado a ainda nesse capítulo, o que eu li até agora é muito bom, e o livro cobre muitos tópicos que não são devidamente discutidos em outros livros Grails .

Infelizmente não posso oferecer qualquer experiência pessoal sobre esta última opção, mas ele faz factível de som (e bastante promissor). Independentemente da opção escolhida, deixe-nos saber como ele sair!

Answer 3

Este post fornece algumas sugestões para a utilização do Grails para embrulho classes Java existentes em um framework web .