Статьи

Создание простого приложения Grails с использованием Oracle JDeveloper

Декабрь 17, 2017
Новое для Грааля? Хотите знать, что это такое? Как показано в этой статье, Oracle JDeveloper предоставляет обширную косвенную поддержку, чтобы помочь вам изучить и использовать Grails.
Ниже следует перепечатка недавней статьи о Grails и JDeveloper, написанной Харшадом Оаком. Харшад ([email protected]) является основателем Rightrix Solutions и директором Oracle ACE для промежуточного программного обеспечения Oracle Fusion. Он является автором Oracle JDeveloper 10g: Empowering J2EE Development (Apress, 2004) и Pro Jakarta Commons (Apress, 2004), а также соавтором Java 2 Enterprise Edition 1.4 Bible (Wiley & Sons, 2003). — Гертьян Виленга, лидер зоны JavaLobby

После волны Ruby on Rails (RoR) большинство разработчиков программного обеспечения рассмотрели, если не испытали, либо ROR, либо какую-то другую среду, которая обещает предоставить функции ROR. Платформа Grails также привела к популярности Rails, но теперь сама по себе превращается в мощную платформу. Grails использует язык программирования Groovy ; Groovy синтаксис похож на Java, но он также принимает некоторые концепции из других языков. Как и Java, Groovy генерирует байт-коды и работает на платформе Java, поэтому обладает мощью Java, но также добавляет некоторые тонкости и упрощения.

В этой статье вы познакомитесь с разработкой приложений Grails с использованием Oracle JDeveloper в качестве вашей IDE. Вы также получите обзор концепций Groovy при разработке приложения Grails.

Настроить

Oracle JDeveloper имеет одну из самых простых процедур установки из всех IDE. Загрузите соответствующий пакет, распакуйте его в каталог по вашему выбору, и вы готовы к работе. Если вы работаете в Windows, запустите файл jdeveloper.exe; в Linux запустите скрипт jdev. Если вы новичок в Oracle JDeveloper, я бы порекомендовал вам загрузить Oracle JDeveloper Studio Edition, который включает в себя JDK — он должен позволить вам запустить Oracle JDeveloper без проблем в Windows и Linux.

Oracle JDeveloper не предлагает поддержку Groovy «из коробки», но для Oracle JDeveloper 10.1.3 доступно расширение Groovy. Чтобы установить это расширение, перейдите в « Справка» -> «Проверить наличие обновлений» . В списке Центры обновлений выберите Расширения с открытым исходным кодом и Расширения партнеров . Нажмите Далее . В появившемся списке выберите Groovy и нажмите « Готово» . Groovy будет загружен и установлен как расширение для Oracle JDeveloper.

Расширение Groovy добавляет библиотеку Groovy в список библиотек, а также добавляет возможность создания сценариев Groovy в Новой галерее. Расширение Groovy недоступно в Oracle JDeveloper 11 g с версии Technology Preview 3. (Обратите внимание, что установка расширения Groovy не является обязательной. Чтобы использовать Grails, вам не нужно устанавливать расширение Groovy или даже сам Groovy для установки на вашем компьютере. )

Установить Grails

На момент написания этой статьи текущая версия Grails — 1.0.1, а Groovy — 1.5.4. Установка довольно проста. Все, что вам нужно, это JDK 1.4 или выше и соответствующая переменная среды JAVA_HOME, указывающая на установку JDK. Теперь загрузите последний бинарный выпуск Grails и извлеките содержимое в папку по вашему выбору. Обратите внимание: поскольку Grails включает файлы JAR Groovy, вам не нужно отдельно загружать и устанавливать Groovy.

Затем создайте переменную среды GRAILS_HOME, которая указывает на каталог. Добавьте% GRAILS_HOME% \ bin в переменную PATH. Не упустите орфографические ошибки и пробелы в переменных окружения. Кажется, я регулярно делаю такие ошибки, а потом провожу много времени, пытаясь понять, почему это не сработает. Если вы неправильно установили JAVA_HOME на компьютере с Windows, вы получите сообщение «Система не может найти указанный путь». Сообщение не дает понять, что проблема связана с JAVA_HOME, а не с файлом .bat или другими переменными среды.

Если вы работаете в Windows, вы также можете использовать более простой установщик Grails на основе .exe. Также доступен установщик .deb для разновидностей Linux на основе Debian (см. Раздел ссылок в конце этой статьи).

Теперь, когда Grails настроен, давайте приступим к разработке веб-приложения, которое будет автоматизировать процесс регистрации докладчиков и подачи докладов на конференцию.

Oracle JDeveloper Первые шаги

Вся разработка с Oracle JDeveloper начинается с создания приложения и проекта. Создайте новое приложение через Файл -> Создать . Назовите приложение Grails. Выберите Нет шаблона [Все технологии] в качестве шаблона приложения. Укажите confmgt в качестве префикса пакета приложения и Conference в качестве имени проекта.

Соглашения и код Grails: внешние инструменты Oracle JDeveloper

Основная идея Grails заключается в том, что если разработчик просто соблюдает определенные соглашения, среда автоматически генерирует файлы, каталоги и код для приложения. Он также будет управлять приложением и запускать его, не спрашивая у разработчика инструкции по каждой мелочи. Если разработчик придерживается соглашений, Grails уже знает, что делать при каких обстоятельствах.

При обычной веб-разработке на Java вы получаете большую гибкость в отношении того, как вы структурируете приложение, где храните файлы, каковы имена файлов и так далее. Однако с Grails вы должны соблюдать соглашения, большинство из которых можно настраивать. Это требует некоторого привыкания, но, безусловно, экономит ваше время и усилия, потому что все утомительные и повторяемые задачи выполняются Grails. Наличие строгих соглашений также очень хорошо, потому что как только вы поймете работу одного приложения Grails, вы можете легко понять любое другое, что не всегда имеет место для обычной веб-разработки на Java.

Grails предоставляет различные команды для автоматической генерации кода. Если вы введете команду grails help после командной строки, вы увидите список различных доступных команд Grails. Мы можем интегрировать эти команды в Oracle JDeveloper с помощью функции External Tools:

  1. Выберите Инструменты -> Внешние инструменты .
  2. В появившемся диалоговом окне нажмите кнопку « Создать» .
  3. Выберите Внешнюю программу в качестве типа инструмента.
  4. Нажмите Далее .

Теперь вы можете создавать, редактировать и запускать приложение Grails, не выходя из среды Oracle JDeveloper.

Как показано ниже, введите <your-grails-directory-path> /bin/grails.bat в качестве исполняемого файла программы на компьютере с Windows и <your-grails-directory-path> / bin / grails на компьютере с Linux. Государственная помощь в качестве аргумента. Каталог запуска не важен в этом конкретном случае, потому что команда help выдаст желаемый результат независимо от того, где вы его запускаете. Однако каталог run важен для большинства других команд Grails. Затем укажите подсказку, а также решите, где вы хотите, чтобы ссылка на инструмент появлялась в Oracle JDeveloper. Вы можете сделать так, чтобы инструменты появлялись в контекстных меню, а также в кнопках на панели инструментов.

Рисунок 1. Внешний инструмент Oracle JDeveloper для команды помощи Grails

Как показано ниже, вы также можете выбрать сохранение всех файлов или перезагрузку всех открытых файлов до запуска инструмента. Нажмите
Готово, чтобы создать новый инструмент. Теперь вы должны увидеть свой новый инструмент в списке в выбранном вами месте; по умолчанию он отображается в меню «Инструменты». Нажмите на инструмент, и команда помощи Grails будет выполнена, и в окне журнала появится список различных команд Grails. По мере продвижения вы будете создавать больше инструментов.

Рисунок 2 Настройки внешнего инструмента

Oracle JDeveloper пока не имеет возможности импорта / экспорта для внешних инструментов, поэтому поделиться своими инструментами с другими в вашей команде не так просто, как могло бы быть. Однако вы можете переместить внешние инструменты в Oracle JDeveloper 10.1.3 в другие установки Oracle JDeveloper, просто скопировав соответствующий XML из файла jdevhome / system / oracle.jdeveloper.10.1.3.40.66 / tools.xml в tools.xml файл на новой машине. В Oracle JDeveloper 11 g нет файла tools.xml; вместо этого все настройки находятся в едином файле product-preferences.xml. Этот файл можно найти по адресу C: \ Users \ username \ AppData \ Roaming \ Oracle JDeveloper \ system11.1.1.0.20.46.84 \ o.jdeveloper на компьютере с Windows Vista.

Вам может быть интересно, почему вы должны использовать внешние инструменты, а не просто запускать команды из командной строки. Большим преимуществом использования внешних инструментов является то, что вы можете сделать все правильно из интерфейса Oracle JDeveloper. Для новичков Grails это также проще, поскольку внешние инструменты могут быть настроены на автоматическое предоставление различных каталогов и путей проекта в качестве аргументов команды. Возможность внешних инструментов автоматически сохранять файлы и предоставлять подсказки и подсказки еще больше упрощает работу. После того, как вы создали внешние инструменты и поделились ими со своей командой, вы можете быть уверены, что каждый из них запускает правильные команды в нужных местах. И последнее, но не менее важное: использовать внешние инструменты намного проще, чем вводить команды после приглашения.

Создать приложение Grails

Grails предоставляет команду create-app, которая создает базовую структуру приложения Grails. Чтобы выполнить эту команду, создайте новый внешний инструмент со следующими параметрами инструмента:

Исполняемый файл программы: $ {env: var = GRAILS_HOME} \ bin \ grails.bat

Аргументы: create-app $ {promptl: label = Name}

Запустить каталог: $ {workspace.dir}

В поле аргументов укажите, что Oracle JDeveloper должен дать вам подсказку, в которой вы можете указать имя приложения. Нажмите кнопку « Вставить» в мастере создания инструмента, чтобы изучить различные другие макросы, предоставляемые Oracle JDeveloper. Эти макросы могут помочь вам предоставить динамические значения в качестве входных данных для различных команд Grails. Поскольку вы указали каталог рабочего пространства в качестве каталога запуска для инструмента, в этом каталоге будут созданы все файлы и папки, созданные командой create-app .

Выполните команду create-app , используя внешний инструмент, и после приглашения укажите имя приложения Conference . В журнале вы увидите множество каталогов и файлов, созданных Grails.

Однако Oracle JDeveloper не будет отображать код, поскольку по умолчанию он ищет исходный код проекта в каталоге <project-directory> / src. Поскольку вы создали весь свой код в самом каталоге рабочего пространства, вам нужно добавить этот каталог в Свойства проекта -> Содержимое проекта -> Содержимое Java . Нажмите кнопку « Обновить» , и появится навигатор приложений, как показано на рисунке 3.

Рисунок 3 Навигатор приложений

Базовая структура приложения уже создана. Просмотрите различные каталоги и файлы, чтобы увидеть, как Grails организует веб-приложение. Обратите внимание, что пустые каталоги, созданные Grails, не перечислены в Навигаторе приложений. Вы увидите, что Grails создал каталоги, такие как view, taglibs, services и controllers, эффективно вынуждая разработчиков организовывать свой код на основе его функциональности. Это хорошо для командных проектов, потому что вы можете быть уверены, что все члены команды следуют соглашению, а не просто делают свое дело.

Теперь давайте приступим к созданию пользовательского приложения, которое обеспечивает регистрацию докладчиков, вход в систему докладчиков и подачу документов.

Динамик и бумага

Grails предоставляет мощный механизм персистентности в форме GORM (объектно-реляционное отображение Grails), которое основано на объектно-реляционной персистентности Hibernate. Таким образом, разработчик создает классы домена и определяет отношения между ними. Постоянство заботится о GORM.

Классы доменов лежат в основе большинства управляемых данными веб-приложений, которые вы разрабатываете с помощью Grails. Классы предметной области являются особыми не только из-за отношений, правил и логики, которые они содержат, но также из-за возможностей, которые Grails внедряет в них во время выполнения. В нашем приложении мы создадим два класса домена, Speaker и Paper, и рассмотрим их возможности. В этом примере дизайн классов домена довольно прост и не нормализован в более мелкие единицы, но вы можете легко нормализовать его, создав новые классы домена и установив отношения между ними, как те, которые вы установили в случае Speaker и Paper.

Чтобы создать классы домена, вам нужно использовать команду Grails create-domain-class . Вы создадите новый внешний инструмент в Oracle JDeveloper, точно такой же, как и инструмент, созданный ранее. Следующее — единственные вещи, которые изменяются:

Исполняемый файл программы: $ {env: var = GRAILS_HOME} \ bin \ grails.bat

Аргументы: create-domain-class $ {promptl: label = Name}

Запустить каталог: $ {project.dir}

Запустите инструмент create-domain-class . Введите Speaker по запросу. Будет создан новый файл /grails-app/domain/Speaker.groovy. Затем создайте класс домена Paper. Файл Paper.groovy также будет создан в каталоге домена. Теперь вам нужно определить свойства Speaker и Paper, а также отношения между ними.

Откройте Speaker.groovy в Oracle JDeveloper. Если вы используете Oracle JDeveloper 10.1.3 и установили плагин Groovy, вы увидите значки, отмечающие файлы .groovy. Отредактируйте файл Speaker.groovy, как показано ниже.

class Speaker { 

 // Fields
 String userid
 String password
 String fname
 String lname
 
 String address1
 String address2
 String city
 String state
 String country
 String bio
 String company
 String speakingExp
 
 String email
 String phone
 String mobile
 
 //default values
 String status = "active"
 Date lastLoginDate = new Date()
 Date registerDate = new Date()

 // Optional - Can be null 
 def optionals = [ "status", "address2", "company","mobile", "speakingExp"]
 
 // One speaker has many papers
 static hasMany = [papers:Paper]

 // Constraints used for validations
 static constraints = {
 userid(size:5..10,unique:true)
 password(size:5..10)
 fname(size:1..30)
 lname(size:1..30)
 email(email:true)
 phone(size:6..15)
 city(size:1..20)
 state(size:1..20)
 country(size:1..20)
 address1(size:5..200)
 bio(size:10..1000)
 }
 
}

В классе Speaker вы определяете свойства для информации, которую вы хотите предоставить докладчику, поля, которые могут быть нулевыми, ограничения для свойств, которые необходимо проверить, и отношения между классами Speaker и Paper. Слова optionals, hasMany и ограничения — это специальные настройки, предлагаемые Grails. В этом примере из-за настройки hasMany Grails вставит свойство Speaker в тип java.util.Set.

Затем измените Paper.groovy, как показано ниже.

class Paper { 

 // Fields
 String title
 String description
 String comments
 String status = "active"
 Date lastModifiedDate = new Date()
 Date createdDate = new Date()
 
 Speaker speaker
 
 //Every paper belongs to a speaker
 def belongsTo = Speaker
 
 static constraints = {
 title(size:5..200)
 description(minSize:10, maxSize:2000)
 } 
 
 def optionals = [ "comments", "status"]
}

Свойство ownTo сообщает Grails, что каждая статья принадлежит докладчику. Таким образом, если спикер удален, документ (ы) этого спикера также будут удалены. Вы снова используете ограничения и дополнительные функции в классе Paper.

Теперь, когда ваши классы домена готовы, вы будете использовать возможности быстрой генерации кода Grails для генерации различных файлов кода, которые ссылаются на применимый класс домена и генерируют код для контроллеров, графического интерфейса пользователя и т.п. По сути, вы можете сгенерировать целое приложение создания / чтения / обновления / удаления (CRUD) для каждого класса домена, просто выполнив одну команду. Вы создадите внешний инструмент для команды generate-all . Параметры для этого внешнего инструмента

Исполняемый файл программы: $ {env: var = GRAILS_HOME} \ bin \ grails.bat

Аргументы: все $ {promptl: label = Name}

Запустить каталог: $ {project.dir}

Вам нужно дважды запустить инструмент generate-all , каждый раз предоставляя в качестве аргумента один класс домена. В журнале будут показаны все файлы и каталоги, созданные Grails. Теперь вы готовы опробовать приложение Grails с возможностями CRUD для Speaker и Paper. Давайте попробуем запустить это автоматически сгенерированное приложение, прежде чем перейти к его настройке. Вы можете сделать это первым, просто запустив команду run-app . Создайте внешний инструмент для команды run-app со следующими настройками:

Исполняемый файл программы: $ {env: var = GRAILS_HOME} \ bin \ grails.bat

Аргументы: run-app

Run каталог: $ {project.dir}

Grails поставляется со встроенным сервером Jetty, и когда вы выполняете команду run-app , сервер запускается и на нем развертывается ваше приложение. Хотя вы можете запустить приложение Grails на любом сервере Java EE, запустить его на встроенном сервере — самый простой вариант во время разработки. Посетите http: // localhost: 8080 / Conference / в своем браузере, и вы найдете веб-приложение, которое может добавлять, редактировать и удалять докладчики и документы.

Источник данных

Конфигурацию источника данных можно найти в файле grails-app / conf / DataSource.groovy. Grails поставляется со встроенной базой данных HSQL, которую можно настроить с помощью этого файла. Обратите внимание, что по умолчанию значением свойства dbCreate является «create-drop». Таким образом, каждый раз, когда вы перезагружаете свой сервер, старая база данных удаляется и создается новая база данных. Измените значение на «обновить», если вы хотите сохранить старые значения.

Чтобы использовать базу данных, отличную от HSQL, добавьте драйвер JDBC для базы данных в каталог lib, а затем добавьте строку подключения и имя класса драйвера в файл конфигурации DataSource.groovy. Например, чтобы использовать Oracle Database 10 g Express Edition в качестве рабочей базы данных, вы должны добавить тонкий драйвер Oracle JDBC в каталог lib, а затем отредактировать файл DataSource.groovy следующим образом:

production {
	dataSource {
	dbCreate = "update"
	url = "jdbc:oracle:thin:@localhost:1521:XE"
	driverClassName = "oracle.jdbc.OracleDriver" 
	}
	}

Создатели Grails предусмотрели очень распространенное требование разработки приложений: необходимость переключаться между базами данных разработки, тестирования и производства, поэтому вы увидите несколько конфигураций источника данных в файле DataSource.groovy. Вы можете изменить базу данных, используемую для запуска приложения, передав аргумент (dev, test, prod) команде
run-app . Значением по умолчанию является «разработка» или «разработка».

	
grails run-app
grails dev run-app 
grails prod run-app 
grails test run-app

Теперь у вас есть приложение, которое может использовать организатор конференции для ввода данных докладчика и доклада, но приложение определенно не в форме для публикации в Интернете и непосредственного использования докладчиками. Давайте разберемся, как работает Grails, а затем настроим приложение.

Домены, контроллеры и представления

Работа Grails вращается вокруг доменов, контроллеров и представлений. Давайте проанализируем один поток в Grails, чтобы выяснить, как работает Grails. Страница, отображаемая по адресу http: // localhost: 8080 / Conference, имеет ссылку на http: // localhost: 8080 / Conference / speaker /. Нажав на эту ссылку, вы попадете на страницу со списком докладчиков по адресу http: // localhost: 8080 / Conference / speaker / list. Шаги, вовлеченные в этот случай, следующие:

  1. Поскольку у Grails есть определенные соглашения, вам не нужно указывать, что когда приходит запрос типа X, он должен использовать Y-контроллер. Поэтому, если запрос имеет вид / speaker / *, Grails автоматически найдет SpeakerController в каталоге / grails-app / controllers.
  2. SpeakerController — это класс, который был сгенерирован автоматически при запуске команды generate-all . Этот класс определяет замыкания для различных действий. По умолчанию используется действие индекса, а закрытие индекса 
    def index = { redirect(action:list,params:params) }

    Это закрытие просто перенаправляет запрос на действие списка вместе с параметрами, полученными в запросе.

  3. Список действий выглядит следующим образом: 
    def list = {
            if(!params.max) params.max = 10
            [ speakerList: Speaker.list( params ) ]
        }

    Он выбирает список ораторов и возвращает карту, ключом которой является speakerList, а значением является список объектов Speaker.

  4. Поскольку мы не упомянули, что Grails должен делать после этого возвращения, соглашения снова входят в картину. Поэтому для действия с именем «list» в контроллере SpeakerController Grails автоматически переходит в представление list.gsp в каталоге / views / speaker и отображает это представление.
  5. list.gsp выполняет итерацию по speakerList, каждый раз используя тег GSP .
  6. Вы получаете страницу, которая отображает список ораторов.

Теперь, когда мы знаем, как работает приложение, давайте перейдем к изменению контроллеров и представлений для пользовательского приложения регистрации и представления докладчиков.

Настроить макет

Grails использует SiteMesh для макетов. Эти макеты находятся в каталоге grails-app / views / layouts. В представлении list.gsp, которое мы рассмотрели ранее, вы заметите строку

<meta name="layout" content="main"></meta>

Это говорит Grails использовать макет, как указано в main.gsp для этого конкретного представления. Поэтому, если вы хотите изменить макет страницы, вам нужно отредактировать файл main.gsp. Давайте изменим логотип с логотипа Grails на логотип OTN, который был размещен в каталоге web-app / images /.

<div class="logo"><img src="${createLinkTo(dir:'images',file:'otn_logo_small.gif')}" alt="OTN" /></div>

Изменяя файл main.gsp, вы можете легко добавлять верхние и нижние колонтитулы, связывать CSS-файлы и вносить другие изменения во все страницы, которые используют этот макет. Обратите внимание, что вместо использования метода main.gsp макет GSP также может обрабатываться с использованием соглашений. Поэтому, если вы создадите макет с именем grails-app / views / layouts / speaker.gsp, он будет применен ко всем представлениям, которым делегируется SpeakerController. Вы также можете создавать макеты для отдельных действий, поэтому макет для действия выхода из системы в LoginController можно определить в grails-app / views / layouts / login / logout.gsp.

Вход в систему

С автоматически созданным приложением на странице http: // localhost: 8080 / Conference вы получите список контроллеров. Вместо этого вы хотите страницу, где оратор может войти в систему / зарегистрироваться в приложении. Ваша первая страница имеет форму входа для ораторов, которые уже зарегистрировались. На странице также есть ссылка Регистрация для тех, кто хочет зарегистрироваться. Для этого давайте создадим представление grails-app / views / login / index.gsp. В Oracle JDeveloper нет мастера для создания файлов GSP, поэтому вам необходимо создать файл GSP, используя Общие -> Файл из новой галереи . Файлы GSP очень похожи на файлы JSP и состоят из тегов HTML и GSP. Таким образом, вы можете получить подсветку синтаксиса для файлов GSP, связав расширение .gsp с типом файла JSP Source в Сервис -> Настройки -> Типы файлов., Внимание: не используйте инструмент Reformat для вашего файла JSP, потому что ваш код GSP будет испорчен, когда Oracle JDeveloper попытается переформатировать его, используя правила, предназначенные для JSP.

Теперь отредактируйте файл index.gsp, как показано в Grails \ Conference \ grails-app \ views \ login \ index.gsp ( пример кода zip ). Обратите внимание на использование тегов GSP if , form и link . Как и в случае других файлов gsp, созданных Grails, макет управляется с помощью поддержки Grails для SiteMesh.

Зарегистрировать спикера

Прежде чем ораторы смогут войти в приложение, они должны сначала зарегистрироваться. Для этого вы предоставили ссылку, которая указывает на SpeakerController и действие create из index.gsp, который мы создали в предыдущем разделе. Действие create в SpeakerController, а также представление create.gsp уже были автоматически сгенерированы Grails. Вам необходимо изменить их в соответствии с этим требованием.

Сначала измените файл Grails \ Conference \ grails-app \ views \ speaker \ create.gsp ( образец zip-кода ) и избавьтесь от всех полей, для которых вы определили значение по умолчанию и не хотите, чтобы пользователь вводил данные. Таким образом, мы избавляемся от полей lastLoginDate, status, optionals и registerDate и модифицируем speakExp в текстовую область вместо текстового поля.

В этом GSP мы используем тег hasErrors для отображения любых ошибок валидации, которые могут возникнуть при отправке формы. Также обратите внимание на использование выражений, таких как $ {speaker? .Bio? .EncodeAsHTML ()}, которые получают значение поля био в Speaker и кодируют содержимое как HTML. Также обратите внимание на? оператор, который предназначен для того, чтобы позаботиться о наиболее распространенном исключении в Java, NullPointerException. С? оператор, если ссылка перед ней является нулевой ссылкой, вычисление текущего выражения остановится и будет возвращено нулевое значение.

Обратите внимание, что, хотя мы использовали базовое текстовое поле, Grails предоставляет тег richTextEditor, который вместо этого может предоставить вам простой в использовании редактор HTML. В теге используется текстовый редактор FCKEditor.

LoginController

Для выполнения реальных функций входа в систему при отправке формы имени пользователя и пароля, которую вы создали на странице index.gsp выше, вы создадите новый контроллер LoginController. Сначала создайте внешний инструмент для команды create-controller :

Исполняемый файл программы: $ {env: var = GRAILS_HOME} \ bin \ grails.bat
Аргументы: create-controller $ {promptl: label = Имя контроллера}
Каталог запуска: $ {project.dir}

Теперь запустите
инструмент create-controller и укажите имя контроллера в качестве логина. Будут созданы два файла: /grails-app/controllers/LoginController.groovy и /grails-tests/LoginControllerTests.groovy. Сгенерированный LoginController не имеет функциональности. Измените его, как показано ниже.

class LoginController {
 
 def index = {
 if (session?.speaker) {
 redirect(controller:"paper",action:"index") 
 }
 }
 
 def login = {
	if (params.userid && params.password) {
	def speaker = Speaker.findByUseridAndStatus(params.userid, "active")
	
	String password = params.password
	if (speaker != null && speaker.password == password) {
	session.speaker = speaker
	speaker.lastLoginDate = new Date()
	speaker.save()
	flash.message = "Welcome ${speaker.fname} ${speaker.lname}"
 redirect(controller:"paper",action:"index") 
	} else {
	flash.message = "Invalid Login."
 redirect(action:"index") 
	}
	} 
 else {
 flash.message = "Invalid Login."
 redirect(action:"index") 
 }
	}
	
 
 def logout = {
 session.speaker = null
 flash.message = "You have been logged out"
 redirect(controller:"login",action:"index") 
 }
 
}

В этом контроллере вы определили три действия:

  • Действие index перенаправляет в файл index.gsp.
  • Действие входа проверяет правильность введенного идентификатора пользователя и пароля.
  • Действие выхода из системы делает недействительным объект динамика, который вы сохранили в сеансе во время входа в систему, и возвращает пользователя на страницу индекса.

В действии входа в систему , вы используете методы динамических Grails и вызвать
findBy метод, findByUseridAndStatus. Причина, по которой вы можете вызвать этот метод, хотя в классе домена Speaker такого метода нет, заключается в том, что Grails использует функции Groovy для предоставления динамических методов и свойств, доступных из ваших классов, без определения их или наследования от базового класса. Доступные динамические функции зависят от того, звоните вы из контроллера, из библиотеки тегов или из класса домена. Метод findBy использует свойства класса домена, чтобы разрешить создание выражений метода запроса Grails, и возвращает первый результат запроса.

Обновление бумаги

Наконец, так же, как и в случае с файлом Speaker create.gsp, который вы видели ранее, вам также нужно изменить другие файлы GSP, чтобы избавиться от полей, которые вы не хотите, чтобы пользователь просматривал или редактировал. Поэтому удалите поля status, lastModifiedDate и creationDate из файлов GSP, а в действии обновления PaperController добавьте строку paper.lastModifiedDate = new Date (); сохранять обновленную дату каждый раз, когда вносятся изменения. В действии сохранения добавьте строку paper.speaker = session? .Speaker, чтобы связать создаваемую бумагу с зарегистрированным в данный момент динамиком.

Аутентификация пользователя

Поскольку мы не хотим, чтобы пользователи могли получать доступ к данным без входа в систему и простого ввода правильного URL-адреса и параметров, вам необходимо предусмотреть некоторую аутентификацию в действиях контроллера. Это может быть легко достигнуто с помощью перехватчиков в Grails. Добавьте перехватчик в PaperController, используя следующий код:

def beforeInterceptor = [action:this.&checkUser]   
  
def checkUser() {
     if(!session.speaker) {
            flash.message = "Please login"
            redirect(controller:'login', action:'index')
            return false;
     }
}

Используемый здесь перехватчик before перехватывает обработку перед выполнением действия и вызывает метод checkUser. Если объект динамика, который вы установили в сеансе сразу при входе в систему в LoginController, отсутствует, к действию PaperController обращаются без надлежащего входа в систему, поэтому метод возвращает «false», а следующее действие не выполняется.

UrlMappings

Вы хотите, чтобы поток приложения начинался с экрана входа в систему, который можно открыть по адресу http: // localhost: 8080 / Conference / login / index.gsp. Если вместо использования этого URL-адреса вы хотите отобразить более упрощенный http: // localhost: 8080 / Conference / на страницу входа, отредактируйте файл UrlMappings в каталоге conf:

class UrlMappings {
    static mappings = {
        "/"(controller:"login")
        "/$controller/$action?/$id?" {
            constraints {
                // apply constraints here
            }
        }
    }    
}

Здесь вы добавляете строку «/» (controller: «login»), которая отображает косую черту (/) в контроллере входа. Контроллер входа по умолчанию переходит к действию index, и вы получаете нужную страницу входа.

Последние штрихи

The views and controllers generated for Speaker and Paper provide CRUD capabilities for both domain classes. However, in a real-world scenario, you would not want any new speaker to see a list of all other speakers or delete speakers, or users to be able to see the primary keys or edit the status constants or the created or modified date, and so on. So you need to open view files and make sure what is being included meets your expectations and the needs of the application.

Packaging and Deploying

Grails comes with a useful war command that can package our Grails application into a standard WAR file that can be deployed on any Java EE application server. The war external tool will take the following settings:

Program executable: ${env:var=GRAILS_HOME}\bin\grails.bat Arguments: war Run directory: ${project.dir}

Conclusion

By making a handful of changes to the code autogenerated by Grails, you now have an application that can register new speakers and accept their papers. You can see how Grails domain classes possess immense power to fetch and store data easily; how actions in the controller classes can be modified to give custom views based on some additional flow logic; and, finally, how GSP views are more than capable of generating rich user interfaces with minimal hassles. Grails is currently in version 1.0.1, and the stability and power of Grails portend growing adoption of the framework. Although Oracle JDeveloper does not yet come with special features for Groovy and Grails, Oracle JDeveloper’s external tools capability enables us to quite easily set up Oracle JDeveloper for Grails development.

Copyright © 2008, Oracle. Все права защищены. Первоначально опубликовано Oracle Technology Network.

47
Share: