Статьи

Groovy & Grails Понимание — Часть 2

Ноябрь 18, 2018

Grails

Grails — это веб-фреймворк, основанный на Groovy и Java, который можно развернуть на существующих веб-серверах Java, например, Tomcat или Jetty. Его возможности создания леса позволяют создать новый проект за несколько минут. Grails основан на идее «соглашения о конфигурации», которая позволяет приложению автоматически подключаться по схеме именования (вместо использования файлов конфигурации, например, файлов XML).

Платформа Grails позволяет разрабатывать экземпляры без необходимости какой-либо настройки. Grails выполняет это, автоматически предоставляя веб-контейнер Tomcat и базу данных HSQLDB во время разработки. Grails использует GORM (Grails

Object Relational Mapping) для сохранения модели предметной области. GORM основан на Hibernate. Вы можете протестировать с HSQLDB и запустить в производственном режиме с другой базой данных, просто изменив файл конфигурации (DataSource.groovy). Grails использует Java EE в качестве архитектурной основы и Spring для структурирования приложения посредством внедрения зависимостей. Grails основан на плагинах и предоставляет собственную систему сборки (Gant). На домашней странице Grails есть несколько предопределенных плагинов, расширяющих структуру Grails. Grails был разработан с учетом ряда целей:

  • Предоставить высокопроизводительный веб-фреймворк для платформы Java.
  • Повторно используйте проверенные технологии Java, такие как Hibernate и Spring, с помощью простого и согласованного интерфейса.
  • Предложите последовательную структуру, которая уменьшает путаницу и проста в освоении.
  • Предложите документацию для тех частей платформы, которые важны для ее пользователей.
  • Укажите, что пользователи ожидают в областях, которые часто являются сложными и противоречивыми:
    • Мощная и последовательная постоянная структура.
    • Мощный и простой в использовании шаблон просмотра с использованием GSP (Groovy Server Pages).
    • Динамические библиотеки тегов для легкого создания компонентов веб-страницы.
    • Хорошая поддержка Ajax, которую легко расширять и настраивать.
  • Предоставьте примеры приложений, которые демонстрируют мощь платформы.
  • Обеспечить полный режим разработки, включая веб-сервер и автоматическую перезагрузку ресурсов.

Архитектура

Grails — это фреймворк для веб-приложений с открытым исходным кодом, использующий Groovy (Рисунок 2: Grails построен поверх Groovy). Впервые он был разработан в 2005 году, а первая версия 1.0 была анонсирована в 2008 году.

Arch1

Рисунок: Grails построен поверх Groovy

ArCH2

Рисунок: Архитектура Грааля

Grails опирается на несколько хорошо зарекомендовавших себя программных сред и объединяет их функциональность через Groovy. Эти платформы включают в себя Java Enterprise Edition (Java EE, JEE), Spring, Hibernate и Quartz. Grails сочетает в себе скорость языков сценариев со стабильностью и безопасностью Java и поэтому идеально подходит для корпоративного использования.

Структура каталога Grails

Структура проекта Grails (показанная на рисунке 3 ниже) в значительной степени зависит от соглашения и устанавливает разумную организационную структуру для различных артефактов приложения.

folderStructure

Рисунок: структура проекта

Настройка среды

Необходимо выполнить следующие шаги для настройки среды Grails

  • Установите JDK1.5 или выше из оракула
  • Укажите переменную среды JAVA_HOME в вашей установке JDK.
  • Загрузите последнюю версию Grails с http://grails.org/Download .
  • Разархивировать Grails
  • Создайте переменную среды GRAILS_HOME
  • Добавить GRAILS_HOME / bin в PATH

Доменные классы

Доменные классы являются источником жизненной силы приложения Grails. Соответствующая таблица базы данных автоматически создается для каждого класса домена. Контроллеры и представления получают свои имена из соответствующего класса домена. Здесь хранятся правила проверки, определяются отношения «один ко многим» и многое другое. Ниже команда для создания класса домена:

1
grails create-domain-class domain-class-name

Обратите внимание, что Grails создает и класс домена, и тестовый класс. Мы поместим тестовый класс для использования позже. А пока давайте сосредоточимся на классе домена

Контроллеры лесов и виды

Контроллеры и представления завершают «большую тройку» в приложениях Grails. Шаблон Model / View / Controller (MVC), несомненно, знаком большинству веб-разработчиков. Обеспечивая четкое разделение интересов между этими тремя элементами, ваши усилия окупаются с точки зрения максимальной гибкости и повторного использования. Grails поддерживает как статические, так и динамические леса. Первый пример покажет, как работать со статическими лесами. А потом будет небольшой пример о том, как использовать динамические леса

Статические леса

Чтобы сгенерировать каркасы в Grails, необходимо выполнить следующую команду через командную строку внутри каталога проекта.

staticScafolding

В этом примере будет создан класс домена Address. Контроллер и представления теперь будут сгенерированы для разработчика. Способ генерирования кода основан на шаблонах, которые можно изменить. Помимо действий CRUD, Grails добавляет действие «список». Функции «edit» и «save» работают вместе с «update» и «create».

Создайте create.gsp Создает новый адрес
Читать show.gsp Показать один адрес (на основе ID)
Обновить edit.gsp Получить один адрес (на основе идентификатора), который необходимо изменить
Удалить Нет просмотра Удалить один адрес (на основе идентификатора)
Список list.gsp Список всех адресов
редактировать Нет просмотра Сохранить обновленный адрес
Сохранить Нет просмотра Сохраняет вновь созданный адрес

AddressController теперь выглядит следующим образом. Функции говорят сами за себя.

01
02
03
04
05
06
07
08
09
10
11
Class AddressController {
Def index = { redirect (action:list, param:param)}
//delete , save and update actions only accept post requests
def allowedMethods =[delete: ‘POST’ , save:’POST’ , update: ‘POST’]
def list = {//…….}
def show = {//…….}
def delete = {//…….}
def edit = {//…….}
def update = {//…….}
def create = {//…….}
def save = {//…….}

Динамические леса

Динамические леса в Grails действительно просты. Это может быть достигнуто путем добавления следующей строки внутри контроллера, который должен быть установлен в качестве леса.

1
def scaffold =true

Действия и представления CRUD будут автоматически сгенерированы во время выполнения для ранее определенной модели

Базы данных — ГОРМ

API объектно-реляционного отображения Grails позволяет нам оставаться в сознании объектов Object — не зацикливаясь на SQL, связанном с реляционными базами данных. GORM — это тонкий Groovy фасад над Hibernate. При создании приложения Grails автоматически создает класс источника данных, в котором можно определить конфигурации для различных сред. Это позволяет легко переключаться между этапами разработки, тестирования и производства проекта. Источник данных GORM может быть настроен в grailsapp / conf / DataSource.groovy

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
dataSource {
pooled = true
driverClassName = “org.hsqldb.jdbcDriver”
username =”sa”
password = “”
}
Hibernate {
Cache.use_second_level_cache = true
Cache.use_query_cache = “true”
Cache.provider_class = ‘com.opensymphony.oscace.hibernate.OSCachePovider’
}
Environment {
Development {
dataSource {
// one of ‘create’, create-drop’ , ‘update’
dbCreate= “create-drop”
urk = “jdbc:hsqldb:main:devDB”
}
}
Production {
dataSource {
dbCreate = “update”
url = “jdbc:hsqldb:file:prodDB;shutdown=true”
}
}
}

Контроллеры

Представление и контроллер будут сгенерированы на основе модели и будут автоматически реализовывать действия CRUD. Здесь мы покажем код контроллера по умолчанию для скаффолдинга так, чтобы и отношения между действиями в контроллерах и URL. Это также позволит нам увидеть взаимосвязь между действием и соответствующими страницами Groovy Server (GSP).

создание-контроллер против создания-контроллер

Контроллер будет генерироваться с использованием скаффолдинга, он не только генерирует контроллер, но и генерирует представление GSP с использованием def scaffold = true . Обычно я хотел бы, чтобы вы набрали «grails create-controller User» на этом этапе. Напомним, что команды create- * создают пустой, заглушенный класс. Вместо этого введите grails generate-all User. Команда generate-all записывает полностью реализованный контроллер и соответствующий набор представлений GSP. (Вы также можете набрать generate-views, чтобы увидеть только GSP, или generate-controller, чтобы создать только контроллер.) Вместо однострочного контроллера, который вы привыкли видеть, теперь вы увидите 100 строк кода Groovy.

URL и контроллеры

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
Class UserController {
Static allowedMethods = {save: “POST”, update : “POST” , delete: “POST”|
def index = {
redirect {action: “lisy” , params}
}
def list = {
params.max = Math.mi(params.max ?
                        params.int(‘max’) :10,100)
def create = {
def userInstance =new User ()
userInstance.properties = paams
return { userInstance : userInstance}
def save = {//…….}
def show = {//…….}
def delete = {//…….}
def edit = {//…….}
def update = {//…….}
}

Рассмотрим типы URL-адресов, которые мы видели, работая над приложением: http: // localhost: 9090 / application / user / show / 2 Каждый компонент URL-адреса играет важную роль в соглашении Grails. И, следуя этому соглашению, мы (к счастью) освобождаемся от необходимости соединять наши URL, контроллеры и представления во внешних файлах конфигурации

UrlsLInk

Первая часть URL-адреса — это имя приложения или корень контекста приложения. Следующая часть URL — это имя контроллера. Обратите внимание, что часть Controller в UserController отбрасывается, а первая буква изменяется на строчные. После имени контроллера вы увидите необязательное имя действия. Это имя напрямую соответствует действию в контроллере.

Если мы попробуем «http: // localhost: 9090 / application / user» в нашем веб-браузере, мы получим пустой список пользователей. Поскольку действие не указано, Grails направляет запрос к действию index. Действие index, в свою очередь, перенаправляет запрос на действие списка, передавая также строку запроса. Структура имя: значение, используемая в методе перенаправления, используется во всех контроллерах.

GSP

Grails использует GSP для уровня представления. Groovy на страницах Groovy Server Pages не только определяет основную технологию, но также и язык, который вы можете использовать, если хотите написать один или два коротких сценария. Groovy Taglib и частичные шаблоны предоставляют вам более изощренный способ совместного использования кода и поведения на веб-страницах. GSP являются основой мировоззрения MVC, ориентированного на страницы. Страница является основной единицей измерения. Страница Список предлагает ссылки на страницу Показать. Страница «Показать» позволяет перейти на страницу «Изменить» и т. Д. Являетесь ли вы опытным разработчиком Struts или недавним энтузиастом Rails, вы уже знакомы с этим типом жизненного цикла Web.

Пример страницы GSP (list.gsp) изображен ниже:

01
02
03
04
05
06
07
08
09
10
11
12
<g:each in=”${userInstanceList}”
Satus=”i” var=”userInstance”>
<tr class=”${(i%2)==0?’odd’ : ‘event’}”>
<td>
<g:link action=”show” id=”${userInstance.id}”>
${fieldValue{bean:userInstance, field:’id’)}
</g:link>
</td>
<td>${fieldValue(bean:userInstance, field:’login’)}</td>
<td>${fieldValue(bean:userInstance, field:’password’)}</td>
 
<td>${fieldValue(bean:userInstance, field:’role’)}</td>

Области в Граале

В Grails есть четыре области действия: запрос, flash, сессия и приложение. Каждый из них имеет различную продолжительность жизни

  1. Переменные, помещенные в область запроса, длятся достаточно долго, чтобы отображаться в ответе, а затем отбрасываются.
  2. Значения в области видимости flash (обычно используемые для сообщений об ошибках в Grails) могут выдержать одно перенаправление.
  3. Область действия сеанса используется для значений, которые должны оставаться для нескольких запросов, но ограничены текущим пользователем.
  4. Значения, помещенные в область приложения, являются «глобальными» — они сохраняются до тех пор, пока работает Grails, и они являются общими для всех пользователей.

Сервисы

Сервис Grails используется для отделения вашей бизнес-логики от другого слоя или компонента. Сервисы именуются в формате SomeNameService.groovy и размещаются в каталоге / grails-app / services /. Службы могут использовать функции внедрения зависимостей, и вы можете легко вызывать эти службы из контроллеров.

1
2
3
4
5
6
7
8
Class SearchableService {
Booleab transactional =true
def compass
def compassGps
def searchableMethodFactory
def search (Object[] args){
searcgableMethodFactory.getMethod(“searcg”).invoke(*args)
}

Выше изображен SearchableService. SearchableService (хранящийся в grailsapp / services) был автоматически добавлен в SearchableController с помощью однострочного def searchableService сразу после объявления класса Controller. Это способ, которым Grails использует внедрение зависимостей, или «DI» для краткости. Контроллеры модульного тестирования

Plug-в

Плагины Grails похожи на банки на стероидах. Они могут включать в себя не только один или несколько JAR-файлов, но также GSP, контроллеры, TagLibs, кодеки и многое другое. По сути, это мини-приложения Grails, специально предназначенные для объединения с другими приложениями Grails.

Модульное тестирование

GrailsUnitTestCase и GroovyTestCase оба расширяют блок тестирования JUnit 3.x TestCase.MVC, расширяют случай GrailsUNitTest и делегируют элемент управления тестового случая в ControllerUnitTestCase и TagLibUnitTestCase.

Модульный тест

GrailsUnitTestCase и его потомки предлагают фиктивные сервисы, которые реплицируют сервисы, доступные в интеграционных тестах, без дополнительных затрат на запуск реальных сервисов. GrailsUnitTestCase предоставляет три вспомогательных метода: mockForConstraintsTests (), mockDomain () и mockLogging (). Обычно вам нужно создать интеграционный тест, чтобы написать утверждения относительно этой функциональности. И вы все еще можете, если хотите. Но, зная, что модульные тесты работают намного быстрее, чем интеграционные тесты, приятно иметь возможность смоделировать это поведение.

1
2
3
4
5
6
Import grails.test.*
Class UserTests extends GrailsUnitTestCase {
Void testsimpleConstraints {
Def user = new User ( login: “someone”, password: “xxx”, role :”admin”)
assertFals user.validate()
}}

Например, предположим, что вы хотите проверить валидацию в классе User.

развертывание

Мы можем легко сгенерировать файл WAR и развернуть его на Tomcat, JBoss, GlassFish или на сервере приложений по вашему выбору. Команда «grails clean» очистит и убедится, что вокруг не осталось никаких артефактов режима разработки. После чистой команды выполнить грааль войны. В результате вы должны получить подлинный файл WAR JEE, подходящий для развертывания на любом сервере приложений Java.

1
2
3
4
5
6
Import grails.test.*
Class UserTests extends GrailsUnitTestCase {
Void testsimpleConstraints {
Def user = new User ( login: “someone”, password: “xxx”, role :”admin”)
assertFals user.validate()
}}

Для развертывания WAR нет необходимости в дополнительной настройке сервера — он включает в себя Groovy JAR, Grails, поддерживающие JAR, и все остальное, что вы добавили в каталог lib.

Резюме

Основная цель Grails — быстро и быстро разрабатывать веб-приложения. Grails основан на соглашении о конфигурации и DRY (не повторяйте себя), а не только на том, что мы можем повторно использовать существующий Java-код в Grails, который дает возможность быстро и быстро создавать надежные и стабильные веб-приложения. В этом документе объясняется использование и лучшие практики Groovy и Grails.

Ресурсы

Ссылка: Groovy & Grails Understanding — Part2 от нашего партнера по JCG Нитина Кумара в блоге Tech My Talk .
53
Share: