Java web-фреймворки


Оглавление (нажмите, чтобы открыть):

Java библиотеки и фреймворки

Для ускорения процесса разработки java-приложения широко используют библиотеки (java library) и фреймворки (java framework). С точки зрения Java библиотека представляет собой файл jar, используемый для определения бизнес-логики программы и построения интерфейсной части. Библиотеку необходимо определенным образом прописать в CLASSPATH и подключить к приложению.

Фреймворк (framework) в переводе с английского означает каркас (структура). Java framework — это программная платформа, определяющая архитектуру построения приложения и облегчающее разработку и объединение разных компонентов большого программного проекта.

Использование java фреймворка в разработке web-приложения является каркасным подходом к архитектуре программы, где любая конфигурация программы состоит из двух частей: постоянная часть (каркас приложения), не меняющийся от конфигурации к конфигурации, и переменная часть — сменные модули, определяющие бизнес-логику и интерфейс приложения.

Различие между библиотекой и фреймворком

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

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

Фреймворк Java Server Faces (JSF), описание

Web framework JSF (Java Server Faces) написан на Java и предназначени для web-приложений. Он существенно облегчает разработку пользовательских интерфейсов для Java EE приложений. Данный web framework основывается на использовании компонентов в отличие от прочих MVC-фреймворков, которые управляются запросами. При использовании классов JavaBean состоянием визуальных компонентов можно управлять : сохранить значение при переходе пользователя на другую страницу, и затем восстанавить, при возвращении назад.

Широкое распространение для формирования интерфейса в JSF получили технологии JSP и Facelets.

Платформа Java Server Faces включает:

  • набор API для :
    • представления компонент пользовательского интерфейса и управления их состоянием,
    • обработки событий,
    • валидации поступаемой информации,
    • определения правил навигации,
    • поддержки интернационализации (i18n),
    • поддержки доступности (accessibility).
  • специальную библиотеку JSP тегов для определения интерфейса JSF на JSP странице.

В последнем на данный момент релизе JSF 2.2 от 21.05.2013 выполнена поддержка различных атрибутов HTML 5 и объединение с Java EE 7. В JSF 2.0 в качестве обработчика представления используется технология Facelets которая пришла на замену JSP.

Подробное описание web framework’а JSF представлено в разделе WEB технологии.

Фреймворк Stuts2, описание

Web framework Struts2 поставляется с открытым исходным кодом и предназначен для создания WEB-приложений в технологии Java2EE. Основой Struts является Java Servlet API, который он расширяет. В архитектурном плане данный фреймворк реализует, или, точнее, дает возможность реализовать шаблоный подход MVC. Struts2 имеется чёткое разделение моделей бизнес-логики, представления HTML-страницы и контроллера, отвечающего за передачу данных от модели к представлению и обратно.

Framework Struts2 включает стандартный контроллер — сервлет ActionServlet и различные средства для управления страницами представления (действия, интерцепторы). Разработчик приложения отвечает за написание кода модели и формирование конфигурационного файла struts-config.xml, который связывает воедино модель, представление и контроллер.

Запросы из браузера поступают на сервер (контроллер) в виде «action» (действия), определённых в конфигурационном файле. Когда контроллер получает запрос, он передаёт его соответствующему action-классу. Последний взаимодействует с кодом модели и, согласно правилам навигации, определяет страницу для отправления клиенту. Информация передаётся между моделью и представлением в виде особых JavaBeans. Богатая библиотека тегов позволяет получать данные из бинов и записывать их без Java-кода.

Web framework Struts2 поддерживает интернационализацию i18n, облегчает валидацию данных полученных из веб-формы и предоставляет механизм использования шаблонов «tiles».

Struts2 не является доработкой предыдущей версии Struts, это абсолютно новый фреймворк построенный на основе Webwork с использованием Model-View-Controller (MVC).

Подробное описание web framework’а Struts2 представлено в разделе WEB технологии.

Фреймворк Google Web Toolkit, описание

Google Web Toolkit (GWT) — это свободный Java фреймворк, обеспечивающий WEB разработчикам создание Ajax-приложений. Основная особенность GWT — это компиляция исходного Java-приложения в JavaScript реализацию (при желании с обфускацией). Фреймворк позволяет почти всю разработку клиента и сервера реализовать на основе Java, и лишь на последнем этапе создать соответствующие JavaScript’ы.

Используя framework GWT, можно быстро разрабатывать и отлаживать AJAX приложения на языке Java с использованием инструментария отладки Java.

GWT включает XML парсер, поддерживает интернационализацию и интеграцию с JUnit, включает интерфейс для удаленного вызова процедур, содержит небольшой пакет виджетов для разработки элементов графического интерфейса пользователя (GUI). Большой набор визуальных компонентов типа GXT (Ext-GWT), SmartGWT позволяют существенно упростить и ускорить разработку интерфейсной части WEB-приложения.

IDE разработки WEB-приложений, как правило, имеют соответствующие плагины для работы с GWT. Отладка GWT-приложения разделена на две части. Отладка серверной части приложения осуществляется как отладка обычного Java WEB приложения. Для отладки же клиентской части понадобится gwt dev-plugin для браузера.

Подробное описание фреймворка GWT с инcталляцией плагина GWT SDK в IDE Eclipse представлено на странице Фреймворк GWT.

Фреймворк Spring, описание

Spring — это универсальный фреймворк с открытым исходным кодом для платформы Java. Также существует фреймворк и для платформы .NET, названный Spring.NET.

Несмотря на то, что Spring не обеспечивает какую-либо конкретную модель программирования, он получил широкое распространёние в Java-сообществе главным образом как альтернатива и замена модели Enterprise JavaBeans.

Spring был выпущен под лицензией Apache 2.0 license в июне 2003 года. Релиз Spring 3.1 вышел в декабре 2011. Текущая версия — 4.2.

Spring обеспечивает бо́льшую свободу в проектировании; кроме того, он предоставляет хорошо документированные и лёгкие в использовании средства решения проблем, возникающие при создании приложений корпоративного масштаба.

Особенности ядра Spring позволяют использовать его в любом Java-приложении. Существует множество расширений и усовершенствований для построения WEB приложений на платформе Java Enterprise Edition. По этим причинам Spring приобрёл большую популярность и признаётся разработчиками как стратегически важный фреймворк.

Наиболее известен Spring как источник расширений функциональности (свойств), нужных для эффективной разработки сложных бизнес-приложений вне тяжеловесных программных моделей. Этот фреймворк предлагает последовательную модель и делает её применимой к большинству типов приложений, которые уже созданы на основе платформы Java. Считается, что Spring реализует модель разработки, основанную на лучших стандартах индустрии, и делает её доступной во многих областях Java.

Более подробно с описанием Spring можно познакомиться на странице Википедии.

Библиотека Hibernate, описание

Библиотека Hibernate предназначена для решения задач объектно-реляционного отображения (object-relational mapping — ORM) при программировании на Java. Она относится к свободно программному обеспечению с открытым исходным кодом (open source), распространяемое на условиях GNU Lesser General Public License.

Hibernate предоставляет легкий в использовании каркас для работы с объектно-ориентированной моделью данных в традиционных реляционных СУБД. Библиотеку можно использовать как в процессе проектирования системы классов и таблиц «с нуля», так и для работы с уже существующей базой данных.

Hibernate не только обеспечивает связь между классами Java и таблицами базы данных, а также соответствие типов данных Java с типами данных SQL, но также предоставляет средства для автоматической генерации и обновления набора таблиц, построения запросов и обработки полученных данных. Таким образом, библиотека позволяет значительно уменьшить время разработки, которое обычно тратится на ручное написание SQL-запросов с использованием JDBC-кода.

Одним из основных достоинств Hibernate является автоматическая генерация SQL-запросов и обработка результирующего набора данных по преобразованию объектов (сериализация объектов), максимально облегчая перенос (портирование) приложения на любые базы данных SQL. То есть, Hibernate обеспечивает прозрачную поддержку сохранности данных (persistence) для «POJO» (Plain Old Java Object). POJO класс Java содержит только поля, без дополнительной логики их обработки, и доступ ко всем полям осуществляется только через методы get/set. Пример простого класса POJO приведен на странице описания компонента JavaBean.

Более подробное описание библиотеки Hibernate с инcталляцией плагина Hibernate Tools в IDE Eclipse представлено на странице Библиотека Hibernate.

Библиотека Swing, описание

Библиотека Swing предназначениа для создания графического интерфейса desktop’ых приложений, разрабатываемых на языке Java. Swing был создан компанией Sun Microsystems и содержит ряд графических компонентов (widget), таких как кнопки, поля ввода, таблицы и т.д.

Swing относится к библиотеке классов JFC (Java Foundation Classes), которая представляет собой набор библиотек для разработки графических оболочек. В состав JFC входят, в частности, библиотека Java 2D и первая библиотека Java для создания пользовательских интерфейсов AWT (Abstract Window Toolkit).

Начиная с версии Java 1.2 (1998 год) Swing включён в Java Runtime Environment.

Look and Feel

Архитектура Swing разработана таким образом, что можно изменять «look and feel» (L&F) приложения. «Look» определяет внешний вид компонентов, а «Feel» — их поведение. JRE предоставляет следующие L&F:

  • CrossPlatformLookAndFeel — родной для приложений Java L&F, иначе называется Metal; используется по умолчанию и обеспечивает стандартное поведение компонентов и их внешний вид, вне зависимости от платформы.
  • SystemLookAndFeel — родной для системы L&F; системный L&F определяется во время выполнения. Для Windows используется «Windows» L&F, который имитирует особенности конкретной системы, на которой запущен. Для Linux и Solaris используется «GTK+», если установлен GTK+ 2.2 или более поздняя версия, в противном случае используется «Motif».
  • Synth — это основа для создания собственных L&F.
  • Multiplexing — предоставляет возможность использования различных L&F одновременно.

Таким образом, компоненты Swing поддерживают специфические динамически подключаемые виды и поведения (plugable look-and-feel), благодаря которым возможна адаптация интерфейса приложения к графическому интерфейсу платформы. То есть к компоненту можно динамически подключить другой, специфический для операционной системы. Таким образом, приложения, использующие Swing, могут выглядеть как «родные» приложения для данной операционной системы.

Сравнение с AWT

Swing предоставляет более гибкие интерфейсные компоненты, по сравнению с более ранней библиотекой AWT. В отличие от AWT, компоненты Swing разработаны для кросс-платформенной работы, в то время как компоненты AWT повторяют интерфейс исполняемой платформы без изменений.

AWT использует только стандартные элементы операционной системы (ОС) для отображения, то есть для каждого элемента создается отдельный объект ОС (окно), в связи с чем, AWT не позволяет создавать элементы произвольной формы (возможно использовать только прямоугольные компоненты). Элементы управления на основе AWT всегда отображаются поверх Swing-элементов, т.к. все Swing компоненты отображаются на поверхности контейнера.

Принцип Lightweight

Принцип «Lightweight» означает, что Swing компоненты прорисовываются самими компонентами в родительском окне (например, на JFrame), без использования компонентов операционной системы. В отличие от «тяжелых» компонентов AWT, Swing приложение может иметься только одно окно.

В приложении могут сочетаться компоненты Swing и AWT. Но это может порождать некоторые проблемы — в частности, компоненты AWT всегда перекрывают Swing элементы, а также закрывают собой всплывающие меню JPopupMenu и JComboBox. Для предотвращения этого, у данного типа компонентов имеются методы setLightWeightPopupEnabled (boolean), позволяющие запретить использование «легковесных» всплывающих элементов. При установке данного свойства в true AWT элементы не будут перекрывать меню.

Основным минусом таких «легковесных» (lightweight) компонентов является относительно медленная работа. Положительная сторона — универсальность интерфейса созданных приложений на всех платформах.

Описание библиотеки Swing более подробно с примерами рассматривается на странице Библиотека Swing

Библиотека SWT, Standard Widget Toolkit

Информация о SWT и ее использования в java-приложениях рассматривается на странице Библиотека SWT

Знакомство с фреймворками. Часть 2. Ruby, Java и JScript

В предыдущей части было рассказано о том, что такое фреймворки, зачем они нужны, и какие HTML/CSS, PHP и Python-фреймворки существуют. Из данной статьи вы узнаете о фреймворках, написанных на таких языках программирования, как Ruby, Java и JavaScript.

Ruby-фреймворки

Ruby on Rails (RoR) – этот фреймворк можно справедливо назвать одним из самых известных, удобных и красивых, по мнению разработчиков, фреймворков. Это прогрессивная и динамичная технология, которая позволяет создавать код, используя соглашения вместо конфигураций. RoR используется для написания модельно-ориентированных веб-приложений. Одна из главных особенностей этого фреймворка – возможность создания любого типа веб-приложения, будь то управление проектами, групповой чат, безопасное хранилище данных или просто блог. Данный фреймворк можно использовать практически на любой операционной системе, также он поддерживает множество СУБД.

Sinatra – бесплатно распространяемый фреймворк с открытым исходным кодом, который используется для создания веб-приложений. Идея этого программного каркаса – быстрое создание веб-приложения на Ruby без лишних усилий. Sinatra используется в качестве библиотеки для обработки HTTP на серверной стороне, это фреймворк для тех, кто придерживается минимализма при создании приложения. Главное преимущество этого фреймворка перед Ruby on Rails – стабильность, так как фреймворк практически не меняется, то есть разработчик полностью контролирует свой код. На фреймворке Sinatra основан фреймворк Padrino.

Merb – название фреймворка расшифровывается как «Mongrel (HTTP сервер) + Erb». Это программный каркас с базовой функциональностью, которую можно расширить при помощи других плагинов. Сравнивая Merb с Ruby on Rails, следует отметить, что у него более высокая гибкость и производительность. К сожалению, работа над этим фреймворком была прекращена несколько лет назад; самый последний релиз вы можете найти на GitHub.

Hanami – название этого фреймворка может быть неизвестно большинству пользователей, так как он долгое время, вплоть до января 2020 года, носил название Lotus. Это современный, быстрый, а главное, легковесный фреймворк, который использует на 60% меньше памяти, чем другие Ruby-фреймворки. Это безопасный и в то же время простой программный каркас, который позволяет буквально за минуты писать гибкий код, который в дальнейшем можно легко отредактировать.

Java-фреймворки

Spring – один из самых известных фреймворков для Java-платформы. Spring помогает решить множество задач, стоящих перед разработчиками, при этом он может использоваться при создании как небольших, так и крупных проектов. Иногда Spring также рассматривают как собрание разных фреймворков, которые можно использовать независимо друг от друга. У этого программного каркаса есть собственная платформа MVC для веб-приложений. Spring позволяет выполнять более глобальные задачи, чем многие другие фреймворки: при помощи него вы можете обеспечить свой проект лучшей масштабируемостью, возможностью более простого тестирования и упрощённой интеграцией с другими фреймворками.

Vaadin – это бесплатно распространяемый фреймворк, который подходит для создания насыщенных интернет-приложений (RIA — rich Internet application). Этот программный каркас выделяется тем, что позволяет использовать Java в качестве главного и единственного языка программирования при создании веб-контента. Многие сравнивают Vaadin с фреймворком Google Web Toolkit, так как они предоставляют схожие возможности, к тому же именно Google Web Toolkit фреймворк Vaadin использует для того, чтобы отображать компонентов клиентского интерфейса и взаимодействовать с сервером на стороне пользователя. Поэтому некоторые считают Vaadin надстройкой над Google Web Toolkit, решающей проблемы общения с сервером.

Google Web Toolkit (GWT) – этот фреймворк позволяет вам писать свой проект полностью на языке Java, который затем будет переведен в JavaScript. При создании этого программного каркаса разработчики уделили особое внимание скорости работы веб-приложений, которые созданы при помощи GWT. Это достигается путем использования отдельно загружаемых модулей, на которые разделяется веб-приложение. Поэтому GWT отлично подходит для написания красивых динамических сайтов.

JavaServer Faces (JSF) – данный фреймворк облегчает процесс написания клиентских интерфейсов для приложений на Java EE. Он основывается на использовании компонентов. Благодаря тому, что классы компонентов интерфейса пользователей содержат функциональный компонент, появляется возможность рендеринга на различных устройствах клиента. JSF дает возможность создавать свои компоненты, но можно воспользоваться и уже имеющимися. При желании также можно использовать MVC-подход.

Play – этот фреймворк был написан сразу на двух языках, Scala и Java. Он использует шаблон MVC. В первую очередь этот программный каркас используется для повышения производительности, так как в нем реализованы некоторые интересные идеи, в частности компилируемость. Благодаря строгой статической типизации кода в шаблон не могут быть переданы параметры неправильного типа или URL без контроллера.

JavaScript-фреймворки


AngularJS – основное предназначение данного фреймворка состоит в разработке одностраничных приложений. На данный момент это один из самых востребованных и популярных фреймворков в мире. Из его преимуществ следует выделить декларативный стиль кода, который позволяет сделать код более легковесным, а также облегчает его восприятие. Используя AngularJS, вы можете использовать уже готовые модули, создавать приложения из зависимых или автономных модулей, а также использовать директивы, которые позволяют уделить особое внимание логике и повысить читаемость кода.

Ember.js – основополагающим принципом этого фреймворка являются маршруты, каждому из которых соответствует своя модель. Именно в моделях содержится информация о текущем состоянии приложения. Этот фреймворк обладает рядом собственных преимуществ: отсутствие необходимости писать вспомогательный код, наличие хорошего обработчика путей и модуля для работы с данными. А приложения, реализованные с помощью Ember.js, отличаются актуальностью и быстродействием.

jQuery – это не фреймворк, а библиотека, но использование jQuery так широко распространено, что этот инструмент также необходимо добавить в данную статью. jQuery была представлена общественности 10 лет назад, в 2006 году. В центре внимания данной библиотеки – взаимодействие HTML и JavaScript. Она поможет вам решить проблемы кроссбраузерности и использования Ajax. Это быстрый инструмент с высокой производительностью, который имеет большое количество плагинов. При помощи jQuery вы можете решить практически любую задачу.

Backbone.js – как и в случае с jQuery, это не фреймворк, а библиотека, однако на базе этой библиотеки можно строить свои собственные фреймворки (или использовать уже существующие: Marionette, Thorax, Vertebrae и другие). Backbone.js – это понятная документация, несложный код, малый вес и практичность. Эту библиотеку легко освоить и затем использовать в своей работе.

Polymer – эту библиотеку тоже часто путают с фреймворком. Некоторые называют Polymer самым прозрачным инструментом для создания приложения, потому что эта библиотека полностью разделяет функции HTML, CSS и JS. Polymer использует стандартные веб-компоненты, которые стали еще более доступными для современных браузеров. Несмотря на то, что одни считают эту библиотеку недоработанной, другие успешно применяют Polymer при создании своих приложений.

Фреймворк и библиотека: в чем разница?

После разговора о фреймворках и библиотеках JavaScript необходимо внести ясность в значения этих двух понятий, которые зачастую путают. О том, что такое фреймворк, уже было рассказано ранее, поэтому я перейду к понятию библиотеки. Библиотека – это сборник различных классов и функций определённого языка программирования. Обычно библиотека содержит набор подпрограмм с близкими функциональными свойствами, в отличие от фреймворка, который обладает широким спектром возможностей. То есть, по сути, библиотека – это программный модуль или набор утилит, а фреймворк включает в себя библиотеки и другие инструменты. Если рассматривать эти два понятия с точки зрения построения кода, то библиотека предлагает вам готовое решение, которое вы можете использовать по своему усмотрению; модуль будет внутри вашего кода и никак не будет ограничивать его. С фреймворком ситуация другая: он является каркасом, основой вашего кода, и все, что вы напишете, будет находиться внутри этого каркаса. С точки зрения архитектуры фреймворк уже навязывает вам определённую структуру, которой вы должны следовать; библиотека лишь дает вам готовые решения, которые вы используете при разработке своего приложения.

Заключение

Бегло прочитав статью, непросто сразу разобраться в большом количестве фреймворков. Если у вас стоит вопрос, какой же фреймворк выбрать, ознакомьтесь с каждым из них, чтобы понять, какой будет наиболее удобен и прост в работе именно для вас. У каждого фреймворка есть свои преимущества и свои недостатки, но все они служат одной цели – сделать разработку более быстрым и приятным процессом. Для данной статьи были отобраны только самые популярные фреймворки, упоминание которых часто встречается на просторах Интернета. В действительности же существует множество других программных каркасов, а при желании вы можете даже создать свой собственный. Также рекомендую ознакомиться со статьей в Википедии, где в таблицах сравниваются различные фреймворки.

10 Best Java Web Frameworks to Use in 2020 (100% Future-Proof)

If you are a Java developer, then you are already aware of the sheer amount of Java Web Frameworks that are out there. That is why we’ve made this list for you. These are the ten best Java Web Frameworks, Frameworks that will last a long time, and support you in whatever you need to do regarding modern Java web development.

Before we get into the list, let’s clarify what a “Web Framework” actually is. A Web Framework is a program that allows you to develop web applications. The framework aspect denotes a system or structure that you can modify to easily develop new applications for a specific piece of software.

It simplifies the whole “building” process, so instead of having to make a number of lengthy and complex alterations to the entire software, you can simply use the framework to make specific changes, without having to rewrite all of the code.

Many different Java hosts don’t actually support all of the frameworks we’re about to share with you. That is why we’ve developed a Java hosting service which supports all of the frameworks we’re about to share, and allows you to easily change, alter and develop whatever Java software you wish to work on.

If you want to learn more about our history and what we’re all about, check out this HostAdvice interview with John Larsen.

But let’s get back to what you’re here for (in no particular order) …

1. JSF – JavaServer Faces

JavaServer Faces is supported by Oracle, and as such, it comes with some very in-depth, complex documentation. When reading this information, you’ll notice that you can use this framework for whatever you wish to create in the Java programming language.

Unfortunately, this isn’t the easiest framework to use, nor is it the speediest. However, the big benefit of JavaServer Faces is the wonderful documentation that Oracle has created. Oracle has lead the industry for many years, so they are quite reliable and trustworthy.

This plays an important part in the Java EE – Enterprise Edition of Java – and if you use the IDE software – Integrated Development Environment – it is incredibly convenient as it is built into those environments.

However, should have a very rudimentary understanding of Java with little software experience, be it with this particular software or with programming as a whole, then this will simply be too complex for you due to the intricacy of the framework.

Pros:

  • Supported By Oracle
  • Comes With Fantastic Documentation
  • Excellent Tools
  • Rich Libraries
  • Convenient If You Use >Cons:

  • Slightly Complex
  • Need Prior Experience
  • Slow For Development

2. Struts

Struts is a free, open-source framework that is used to create elegant, aesthetically pleasing Java applications. It is used to develop the foundation of a web application, and it functions on a pattern known as “MVC,” which means Model-View-Controller. In terms of support, there is quite a bit of it, but it’s less “industry-standard” than, for example, JavaServer Faces due to being open source and not having the support of one of the software industry’s leaders.

Unfortunately, Struts is a fairly multifaceted framework and it does take a while to get the hang of it. That being said, it makes for fast development and testing due to being able to immediately implement new segments of code and new elements that you can easily add.

However, if you use Struts, you’ll find that the framework isn’t very flexible and using it means that you need to become accustomed with a set of rules regarding the coding and designing of web applications. This is a big turn-off for most people simply because they have already become accustomed to a specific methodology, and Struts wants you to use their own set of rules.

Pros:

  • Free And Open-Source
  • Fast Development
  • Easy To Test New Code

Cons:

  • Many Rules
  • Complex Framework
  • Not Very Flexible

3. Hibernate

Hibernate is not a Web Framework, but an ORM framework known for being a high-quality and powerful option to deal with database access. As for the specifics of the framework, Hibernate is a device for object-relational mapping, which, in Computer Science, is a means of converting data between two systems that are incompatible, and getting them to work with each other through object-oriented programming languages. In this case, of course, the programming language in question is Java.

So, because of this, you can use Hibernate to communicate with any database that you have, utilizing only a slight change or two with the overall code of your web application. This is incredibly convenient and useful if you tend to work with multiple databases that are otherwise incompatible or difficult to use.

One of the biggest benefits that Hibernate offers, besides speed and being able to work with multiple databases, is the fact that it is very easy to scale whatever software you are writing to bigger and smaller architectures and numbers of users. If you are designing a very specific piece of software that is only going to be used by ten or twenty people, then Hibernate is perfect for you, just as it is ideal if you’re developing a piece of software that is going to be used by hundreds of thousands of people.

Beyond that, Hibernate is easily configurable, modifiable, and you can do just about anything with it. Unfortunately, one of the biggest flaws with Hibernate is that restarting the ORM framework and getting back to where you were can be very slow, and if the power goes off on your computer, you could easily lose all of your data.

Pros:

  • Very Powerful
  • Easy To Convert Data For Multiple Databases
  • Speedy
  • Easy To Scale
  • Easy To Configure And Modify

Cons:

  • Slow To Restart
  • Easy To Lose All Of Your Data

4. GWT – Google Web Toolkit

Google Web Toolkit comes directly from your favorite search engine, Google! It is an open source tool that enables you to easily develop and modify front-end Java applications, regardless of how complex these applications are.

One of the great things about Google Web Toolkit is the fact that it is developed by Google, and as such, it has a lot of support, a lot of great documentation, and the whole thing feels professional well-developed and thorough in its execution.

It is simple to learn, and you can use it to develop those front-end applications that you need, as well as to create these incredibly responsive web applications that balance the load on both the server-side and client-side systems. Along with this, there is the fact that Google Web Toolkit allows you to effortlessly integrate that multifunctionality.

One of the biggest problems with Google Web Toolkit is the fact that there are so many new versions being created, and each one is different in a number of ways. Some versions have specific interfaces and tools that you might find essential, whereas the more stable versions of Google Web Toolkit may be lacking these tools, but they happen to work a lot better. The other problem is that compiling software in the Google Web Toolkit is rather slow, and this can be a big annoyance for many people.

Pros:

  • Easy To Use
  • Accessible
  • Develops Very Responsive Applications
  • Balances The Load On Server And Client-S >Cons:

  • New Versions Are Constantly Being Created
  • Compiling Is A Slow Process

5. Vaadin

The Vaadin framework is open-source and licensed by the Apache Software Foundation, a nonprofit that has been instrumental in the creation and sustenance of tools for programming languages such as Java and C++. As such, this is a very useful, powerful framework that you can use, and there is an incredibly active worldwide community that you can turn to for guidance.

Vaadin is great for developing web applications, and the architecture of Vaadin and Vaadin applications is server-side, rather than client-side, which contrasts with the traditional solutions found with Java and JavaScript. All of this means that you can create rich, interactive web interfaces that enable you to make applications people want to use. If you choose to, you can extend the Vaadin framework with Google Web Tools, as well as with Ajax and the techniques and methods that Ajax offers. What sets Vaadin apart from most is the UI, which is exceptional due to its simplicity and ease of use. In no time at all, you can build a variety of cool web applications.

Unfortunately, there is one small flaw. Given the nature of the Vaadin framework, it’s very easy for your Java or JavaScript code to become incredibly large and convoluted.

Pros:

  • Many Different Plug-Ins
  • Supported By Apache
  • Good Documentation
  • Lots Of Support On The Forums
  • Uses Server-S >Cons:

  • Easy For Code To Become Overly Lengthy And Complex

6. Wicket

Wicket – also known as “Apache Wicket” due to heavy support from the Apache Software Foundation – is a lightweight Web Framework built for designing simple, but elegant web applications in a component-based language that is very useful and responsive. It’s open-source, server-side, and all of the code in this Web Framework is scripted in Java, which makes things significantly easier when it comes to doing all of the scripting and alterations that you may need to make.

You can easily integrate it with HTML, which allows for elegant and simple HTML pages that lack an excess of complexity, making this a perfect framework for Web Designers. Wicket also contains an enormous amount of power and convenience when it comes to testing the applications that you are building. Not only that, but instead of having to open a browser and test the page as a whole, you can use Wicket to test specific components that you are building!

The only flaw with Wicket is that, while there are many perks and conveniences, the development process can be confusing due to the complexity of the Web Framework. But if you’re okay with that, then Wicket is one of the best out there!

Pros:

  • Supports Java And HTML
  • Easy To Maintain Code
  • Easy To Test Specific Components Of Your Code
  • Makes Elegant And Simple Pages And Applications
  • Lots Of Support And Documentation

Cons:

  • Convoluted Development Process
  • Takes A While To Fully Learn The Framework

7. Vert.X

Vert.X is a Web Framework that is very broad in its capabilities. It supports many languages, but the one that it is primarily optimized for is Java. However, if you use Ruby, Ceylon, Groovy, or JavaScript, then you can use all of those on Vert.X, as well. There are many different components of Vert.X, and each one is modular, which allows you to use the things that you like or need in order to write your web application, and discard the rest.

One of the nice things about Vert.X is that it is a library and not a container, which means that you can apply other tools and components from other libraries that you prefer or need for whatever web application you are trying to create.

One of the great things about Vert.X – aside from its flexibility and functionality – is the fact that you can easily set it up and use the components and libraries that you want. This isn’t a difficult process, and due to the flexibility of the framework, there is quite a bit that you can easily do.

It runs on the JVM – Java Virtual Machine – and it enables you to test your code and scale it with immediate ease. This is something to take note of, especially if you also need a variety of components that most other frameworks don’t seem to offer or have a hard time doing.


As for the downsides of this particular Web Framework, it can be difficult to scale when it comes to going from one specific piece of limited hardware to a much larger one, say, a server farm. But, scalability is also one of the strengths of Vert.X, provided the scaling isn’t too large, or else it will take a fair amount of work.

Pros:

  • Really Easy To Set Up
  • Supports Many Languages
  • Highly Modular – Use What You Like, Discard The Rest
  • You Can Use Any Library You Want

Cons:

  • Difficult To Scale Onto Larger Systems

8. Spring MVC – Model View Controller

Spring MVC is one of the oldest Java Web Frameworks, but it’s also one of the best. To this day, it is used, and this is because it is constantly adapting and improving upon specific changes and developments with Java.

For software engineers of any kind, it offers a truly amazing toolkit for developing web applications and configuring these applications, as well as developing the security features that go with them. It is truly a broad and expansive Web Framework that is more than capable of taking on any potential task or project you wish to work on.

Due to the modularity of the tools themselves, this enables you to write code that is very clean and accessible. There is an enormous amount of excellent documentation, and a thriving community that will help you if you have any questions or concerns regarding how to do certain things or how certain things work or anything of that sort.

The biggest downside – and the only real downside – is the fact that this is a complex Web Framework and if you are new to Java programming, then this probably isn’t the best choice simply because it requires a lot of knowledge beforehand, and this makes the learning curve pretty steep.

Pros:

  • Excellent Documentation
  • Extremely Helpful Community
  • Broad And Expansive Toolkit For Any Project You Might Have
  • Enables You To Write Clean And Accessible Code

Cons:

  • Steep Learning Curve
  • Requires Quite A Bit Of Pre-Existing Knowledge Before Using

9. Play!

Play is a very simple and easy to use Web Framework. The general idea behind Play is to allow you to make changes as swiftly and as easily as possible, with minimal effort on your part.

This is done through a seamless and very easy to use UI, along with a number of features made for utilizing the desired amount of resources on your computer – CPU, RAM – that enable you to easily scale the software that you are writing. It was designed for developers who are working on the development of modern web and mobile applications. Applications that rely on a certain level of simplicity and ease of use.

Play is built on the Akka toolkit, which is a very popular open-source toolkit that runs on the Java Virtual Machine, and it comes equipped with the same basic features and tools, but executed in a far more user-friendly manner that enables you to easily write, design, and test the applications that you are developing, all while maintaining a productive and cohesive workflow. Many developers swear by it, and insist that it has actually improved their productivity by a significant amount, due to the simplicity and the ease of use.

If there is a downside, it’s that this current version of Play is actually Play 2. There are very little differences between the two, and there haven’t been many improvements made over the course of that particular development cycle. Right now, Play doesn’t really need any specific improvements, but time will tell as to whether or not Play is going to still be one of the best Web Frameworks next year.

Pros:

  • Improves Your Productivity Greatly
  • Easy Workflow
  • Flexible Tools
  • Everything Works Well When You Start It
  • Excellent Resource Management
  • Easy To Scale Software

Cons:

  • Few Improvements Have Been Made Over The Years

10. Grails

Grails is a very dynamic Web Framework that enables you to immediately start writing the code for your web application, whatever it may be. It’s used within the Java Virtual Machine, and it comes equipped with a variety of powerful tools such as asynchronous programming, Compile-time metaprogramming, along with run-time and domain-specific languages that you can use.

One of the best things about the Grails Web Framework is the fact that it works for any size project, and there are so many supported plugins that allow for that project to be executed smoothly and rapidly, and you can test your developments and modifications out just as easily.

If you follow the documentation, then the setup will be super simple, and they will walk you through developing your first app, and that should only take an hour or two, which makes Grails one of the easiest and most thoroughly developed Web Frameworks. It also supports a variety of IDEs, such as Eclipse and Textmate, two very popular options in the world of Java development.

Really, the only flaw with Grails is the fact that you are forced to use runtime language – the virtual machine of Microsoft’s “.NET” framework – to use the Grails Web Framework.

Pros:

  • Easy To Set Up
  • Over 900 Plugins
  • Excellent Documentation
  • Easy To Use
  • Works For Any Size Of Project

Cons:

  • Forced To Use Runtime Language

Which One Do I Choose?

Each Web Framework that we have listed contains its own pros and cons, as we have listed. One thing to take into consideration is the nature of your web application project, how many people are working on it, and the exact purpose of it. Depending on the scale of your application, you might go for something like Hibernate or Grails.

That, and take into consideration your own level of experience with Java and your own understanding of other Web Frameworks. If you are new to all of this, then Google Web Frameworks may be the way to go. It all depends on a number of factors, but regardless of that, we at JavaPipe support you, and we can host every single one of these Web Frameworks.

To choose, simply consider the nature of your application, the scale of the application, and your experience with using Web Frameworks and writing web applications in Java. Then, choose which one works best for you!

17 Popular Java Frameworks [2020 edition]: Pros, cons, and more

In 2020, Java is still the most popular programming language in the world. It comes with a vast ecosystem and more than 9 million Java developers worldwide. Although Java is not the most straightforward language, you don’t have to write Java programs from scratch. There are many excellent Java frameworks to write web and mobile applications, microservices, and REST APIs that run on the Java Virtual Machine.

Get 100% visibility into Java errors affecting your customers with Raygun Crash Reporting.

Java frameworks allow you to focus on the business logic of your apps instead of writing basic functionality such as making database connections or handling exceptions. Also, if you have some experience with Java, you can get started quickly. The frameworks all use the same syntax and work with similar terms, paradigms, and concepts.

Our top 17 Java frameworks are based on usage through 2020 and listed alphabetically.

Blade: Simple application framework with a minimal footprint

Blade is a lightweight and high-performance Java framework that allows you to build fast web applications in a straightforward way. The creators want users to understand the whole framework in a single day. Therefore, Blade focuses on simplicity and elegance.

The Blade framework follows the MVC (Model-View-Controller) software design pattern. It has an easy-to-understand design, as it doesn’t depend on any third-party libraries or introduces too many layers. Blade is based on Java 8, and the Netty web server and template engine are built into the framework, too. It has a minimal footprint; the source code is less than 500kb in total.

With Blade, you have access to a RESTful-style routing interface and can deploy your app as a basic Maven project. Blade has built-in security features too, for instance, it comes with CSRF (Cross-Site Request Forgery) and XSS (Cross-site scripting) defense. It’s a versatile framework, as it comes with support for plugin extensions and webjar resources. The documentation on the main site is in Chinese. However, it does have English-language documentation in the GitHub repo.

Dropwizard: Production-ready RESTful web services

Dropwizard is a high-performance but straightforward Java framework for rapid development of RESTful web services. It’s especially suitable for creating Java microservices.

The Dropwizard framework pulls together several well-established Java libraries to provide you with a fast and distraction-free development platform. It comes with an embedded Jetty server, Google Guava, Logback, Hibernate Validator, Joda Time, and many other popular Java libraries. Besides, Dropwizard also contains Jersey with which you can build RESTful web services and Jackson for processing JSON. You can think of Dropwizard as a separate ecosystem that contains all the dependencies mentioned above bundled into a single package.

If you choose Dropwizard, you don’t have to spend much time on secondary functionalities like having to write your code for configuration, metrics, or logging. Instead, you can focus on the primary business logic of your app and achieve maximum productivity. That’s why Dropwizard is often referred to as an operations-friendly Java framework. Getting started is not very hard if you have written Java before; the Dropwizard docs even have a simple Hello World example that can help you with the first steps.

Grails: Groovy-based web application framework

Grails is a web application framework that uses the Groovy programming language. Groovy is an object-oriented language for the Java platform that intends to enhance developer productivity. Its syntax is compatible with Java, and it’s compiled to JVM (Java Virtual Machine) bytecode.

Although you need to write your code in Groovy, Grails works well with other Java-related technologies such as the Java Development Kit, Java EE containers, Hibernate, or Spring. Under the hood, Grails is built on top of Spring Boot so that it can make use of its productivity-friendly features such as Spring’s dependency injection. Probably the best thing about Grails is that you can achieve the same results with much less code—thanks to the power of the Groovy language.

Grails follows a handful of modern software development principles such as convention over configuration, opinionated APIs to enforce best practices, and sensible defaults. It’s also very developer-friendly, as it comes with a detailed and easy-to-read documentation, step-by-step guides, and an extensive plugin library. You can also build your own plugins and make use of Grails’ IDE support for Eclipse, Sublime, Textmate, IntelliJ IDEA, and other platforms.

GWT: Google Web Toolkit: client-side Java apps deployed as JavaScript

GWT, or the Google Web Toolkit, is a brilliant web framework created by Google. In fact, GWT fullfills the dream of every developer who wants to build Java apps for the web, as it allows you to write client-side Java code and deploy it as JavaScript for the browser.

GWT is pronounced as “gwit,” and it’s a stable and well-maintained Java framework. Nothing proves that better than its presence in several Google products such as AdWords, AdSense, Blogger, and Google Wallet. Google Web Toolkit has a spectacular website with all the tools and resources you may need, such as tutorials, developer guides, a starter application, and an Eclipse plugin.

The awesome thing about GWT is that you can write complex browser-based apps without being an expert in front-end technologies like JavaScript optimization or responsive design. So, you can use GWT instead of client-side JavaScript frameworks that, as you may have already noticed, come and go on the market sometimes surprisingly quickly. GWT offers many advanced features such as internationalization, cross-browser portability, UI abstraction, bookmarking, and history management.

Hibernate: Object-relational mapping framework for a better database communication

Hibernate is a stable object-relational mapping framework that makes better communication possible between the Java programming language and relational database management systems (RDBMSs).

When you work with object-oriented languages like Java, you’ll encounter a problem called Object-Relational Impedance Mismatch (sometimes also called Paradigm Mismatch). OO languages and RDBMSs handle data differently, which can lead to mis-match problems. While OO languages structure data as a hierarchy of objects, relational databases represent data in a tabular format. For instance, one of these mismatch problems is when the object model has more classes than the number of available tables in the relational database.

Hibernate provides you with a framework that overcomes the mismatch problems of Java. It intends to achieve persistence, meaning that the data created/used by the application should outlive the process that generated it. While Hibernate was built for relational databases, its newer versions provide support for NoSQL datastores as well. It also has excellent developer tools such as a mapping editor, a Hibernate console, and an awesome database reverse engineering tool.

JavaServer Faces (JSF): Component-based UI framework

JavaServer Faces (JSF) is developed by Oracle as a specification for building user interfaces for Java-based web applications. It’s an official standard of the Java Community Process (JCP) initiative as well.

The first version of JavaServer Faces was released back in 2004, so it’s a pretty stable framework. It follows the MVC software design pattern and has a component-based architecture. With JavaServer Faces, you can build user interfaces of reusable components, manage the state of your components, connect them to data sources, and bind user-generated events to event handlers on the server side.

The default templating system of JSF is Facelets that was created explicitly for the project. With Facelets, you can use XML instead of Java for view handling. However, you can also create views with other technologies such as XUL (XML User Interface Language) and plain Java. Web applications created with JavaServer Faces are portable across different Java EE application servers as well.

JHipster: Web apps and microservices with Spring Boot and Angular/React

JHipster is a newer Java framework (released in 2013) that brings the Spring Boot and the two most popular front-end frameworks (Angular and React) together, in one handy application generator. With JHipster, you can quickly generate modern Java-based web applications and microservices.

The Spring Boot allows you to create production-grade Spring-based applications (see more about the Spring Framework below in the article) that work with minimal configuration. JHipster combines it with Angular, React, and Bootstrap on the client side to provide you with a full-stack architecture. If you want to see how a JHipster app looks like in real-life, check out the sample apps for Angular and React, both created by the JHipster team.

JHipster lets you choose between two architectural styles. First, you can opt for a monolithic architecture in which the frontend and backend are combined into a single application. Second, you can go for the microservice architecture that splits the frontend and backend. JHipster also integrates with several tools, and offers a ton of options for client and server-side coding, bundling, plus different DevOps tasks. After all, it’s no coincidence leading brands like Adobe, Siemens, Bosch, HBO, and Google use JHipster.

MyBatis: Persistence framework for easier SQL management


MyBatis is a so-called persistence framework for Java applications, that makes it easier and faster to work with relational (SQL) databases. The framework acts as a middleware between the application and the database and fixes the issues stemming from their different architecture.

You can think of MyBatis as a layer of abstraction between the Java code of your application and the underlying SQL database. By default, you need to use the JDBC (Java Database Connectivity) API to access data sources like relational databases or spreadsheets from your Java code. MyBatis simplifies this process and lets you interact with relational databases with much less code. For instance, you can execute SQL statements with just a single line of code.

In fact, MyBatis is similar to the Hibernate framework, as both aim to improve the communication between the application layer and the database. However, MyBatis doesn’t map Java objects to database tables like Hibernate does, but links Java methods to SQL statements. As a result, SQL is not hidden from you when you are working with the MyBatis framework, and you still have control over the execution of SQL.

Play: Reactive web & mobile framework for highly scalable Java applications

The Play framework makes it possible to build lightweight and web-friendly Java and Scala applications for desktop and mobile interfaces. Play is an incredibly popular framework, used by companies like LinkedIn, Samsung, Walmart, The Guardian, Verizon, and many others.

Play is often compared to powerful web frameworks of other programming languages, such as Ruby on Rails for Ruby, or Django for Python. In fact, Play is a unique Java framework in the sense that it doesn’t rely on the Java EE standards. Instead, it intends to eliminate all the inconveniences of traditional Java web development such as slow development cycles and too much configuration. It more resembles the web frameworks of scripting languages (PHP, Python, Ruby, etc.) as much as possible.

Under the hood, Play is built on top of the Akka toolkit that simplifies the creation of concurrent and distributed applications on the Java Virtual Machine. As a result, Play uses a fully asynchronous model that leads to better scalability, especially because it also follows the statelessness principle.

The Play framework puts developer productivity first by offering features like hot code reloading, convention over configuration, and error messages in the browser. Besides, it’s a Reactive System that follows a modern system architecture (responsive, resilient, elastic, and message-driven) to achieve more flexible and failure-tolerant results.

PrimeFaces: UI framework for Java EE and JavaServer Faces

PrimeFaces is a popular web framework for creating lightweight user interfaces for Java EE and JavaServer Faces (see above) applications. It’s used by many Fortune 500 companies, government entities, and educational institutions.

The PrimeFaces library is truly lightweight. It’s packaged as a single JAR file, requires zero configuration, and doesn’t have any dependencies. It allows you to create a user interface for your Java application by offering you a rich set of components (100+), a built-in skinning framework, and pre-designed themes and layouts. As PrimeFaces is built on top of JavaServer Faces, it inherits its features such as rapid application development. You can also add the framework to any Java projects.

On the PrimeFaces website, you can find an excellent showcase of all PrimeFaces components, templates, and themes. The components come with relevant code snippets you can quickly copy/paste into your app—or tweak them when it’s necessary. For instance, here is a horizontal mega menu that lets you display submenus of root items together.

PrimeFaces also has an awesome theme designer which is a Sass-based theme engine with more than 500 variables, a sample theme, and font icons. And, if you don’t want to build a theme yourself, you can also download a community theme or purchase a premium one from the PrimeFaces Theme Gallery.

Spark Framework: Micro framework for web apps and REST APIs

Spark Framework is a micro framework and domain-specific language for the Java and Kotlin programming languages. Kotlin also runs on JVM, and it’s 100% interoperable with Java. With Spark, you can painlessly develop web applications, microservices, and REST APIs.

Micro frameworks first appeared in scripting languages like Ruby and PHP and quickly gained traction due to their focus on development speed and simplicity. Spark was inspired by the Sinatra web application framework for Ruby and first released in 2011. It’s not an MVC framework but lets you structure your app as you want. As with most micro frameworks, it has a small code base, needs minimal configuration, and doesn’t require you to write too much boilerplate code.

In fact, you can get the Spark framework up and running in just a few minutes. By default, it runs on the Jetty web server that is embedded into the framework. However, you can use it with other Java web servers as well. According to Spark’s own survey, more than 50% of their users used the framework to create REST APIs, which can be seen as its most popular use case. Spark also powers high-traffic web applications serving more than 10,000 users a day.

Spring Framework: Enterprise-level Java application framework

The Spring Framework is probably the most well-known Java framework out there, with a huge ecosystem and an active community around it. It allows you to build enterprise-level Java applications, web services, and microservices.

The Spring Framework started as a dependency injection tool, but over the years it has developed into a full-scale application framework. It provides you with an all-inclusive programming and configuration model that comes with support for generic tasks such as establishing a database connection or handling exceptions. Besides Java, you can also use the framework together with Kotlin and Groovy, both of which run on the Java Virtual Machine.

The Spring Framework utilizes the inversion of control (IoC) software design principle according to which the framework controls the custom-written code (as opposed to traditional programming where the custom code calls into other libraries that handle generic tasks). As a result, you can create loosely coupled modules for your Spring applications.

While the Spring Framework is excellent for building enterprise-level Java applications, it does have a steep learning curve. This is because it’s a broad framework that intends to provide a solution for every task that may come up with an enterprise-level application and also supports many different platforms. Therefore, the configuration, setup, build, and deployment processes all require multiple steps you might not want to deal with, especially if you are working on a smaller project. The Spring Boot (different from the Spring Framework) is a solution for this problem, as it allows you to set up your Spring application faster, with much less configuration.

Struts: MVC framework for enterprise-level Java applications

Struts is quite an old framework, but many people still use it, therefore it’s worth a mention in this article.

Struts is a full-featured Java web application framework maintained and developed by the Apache Software Foundation. It’s a solid platform with a vast community, often compared to the Spring Framework. Struts allow you to create enterprise-level Java applications that are easy to maintain over time.

It follows the MVC software design pattern and has a plugin-based architecture. Plugins make it possible to extend the framework to fit with different project needs. Struts plugins are basic JAR packages. Therefore, they are portable and you can also add them to the classpath of your app. Some plugins are bundled with the framework (JSON plugin, REST plugin, Config Browser Plugin, etc.), while you can add others from third-party sources.

You can integrate Struts with other Java frameworks to perform tasks that are not built into the platform. For instance, you can use the Spring plugin for dependency injection or the Hibernate plugin for object-relational mapping. Struts also let you use different client-side technologies to build the front-end of your app, such as JavaServer Pages or HTML with Angular.

However, if you want to create server-side components that can render on the front-end, Struts may not be the best choice for that. Instead, you should look into a framework that has a different architecture such as Tapestry or Wicket (see both below). Also note that Struts got some bad press recently due to some critical security vulnerabilities you still need to be aware of.

Tapestry: Component-oriented framework for highly scalable apps

Tapestry is a component-based Java framework with which you can create scalable web applications. Its focus on reusable components makes it architecturally similar to JavaServer Faces and the Wicket framework. Just like Struts, Tapestry is also a project of the Apache Software Foundation.

You can write Tapestry pages and components as plain old Java objects (POJOs). Therefore, you can access the whole Java ecosystem from the framework. Besides Java, Tapestry also supports Groovy and Scala and integrates with other Java frameworks such as Hibernate and Spring. Tapestry has been built with performance in mind; therefore it provides you with features like live class reloading, exception reporting, Ajax support, and built-in components and templates.

Tapestry is a developer-friendly framework as well. It has built-in utilities to facilitate test-driven development (TDD) and comes with support for the Selenium testing framework. Tapestry scales nicely both on single servers and server clusters. Apps built with Tapestry run fast in the browser, as it follows a bunch of best practices such as client-side caching, support for concurrent threads, JavaScript aggregation and compression, integrated GZip content compression, and others.

Vaadin: Web application framework with a focus on UX, accessibility, and mobile

Vaadin provides you with a platform for streamlined Java development. It allows you to build web applications of customizable components that focus on performance, UX, and accessibility.

The most interesting thing to know about Vaadin is that its June 2020 release) was so significant that even major media outlets reported it. Vaadin 10 approaches web app development in an entirely new way: it gives developers direct access to the DOM from the Java Virtual Machine. With the new release, the Vaadin team split the previously monolithic framework into two parts. It has a lightweight Java framework called Vaadin Flow that handles routing and server-client communication and a set of UI components that run in the user’s browser.

The components are mobile-first and follow the latest web and accessibility standards; they were built on the Web Components standards. You can use Vaadin components together with any front-end framework such as React, Angular, or Vue. The creators also recommend them as building blocks for Progressive Web Apps. You can build your own theme based on Vaadin components or use Vaadin’s two pre-made themes: Lumo (default) and Material.

Vaadin Flow provides you with a high-level Java API to manage all the technical aspects of your app, from automatic server-client communication via WebSockets to data binding. As Flow runs on the JVM, you have access to the whole Java ecosystem, for instance, you can run your app with the Spring Boot. Flow also lets you write your app in Kotlin or Scala.

Vert.x: Polyglot event-driven application framework for the Java Virtual Machine

Vert.x is a polyglot framework running on the Java Virtual Machine. It allows you to write your apps in programming languages such as Java, JavaScript, Groovy, Ruby, Scala, and Kotlin. Its event-driven architecture results in applications that scale nicely even with minimal hardware resources.

Vert.x is developed and maintained by the Eclipse Foundation whose most famous project is the Eclipse IDE for Java development. And, who would know more about Java than the creator of Eclipse? The ‘x’ in Vert.x refers to its polyglottic nature, meaning that you can write valid code in several different languages. It provides idiomatic APIs for every supported programming language.

As Vert.x is an event-driven and non-blocking framework, it can handle a lot of concurrencies using only a minimal number of threads. Vert.x is also quite lightweight, with the core framework weighing only about 650 kb. It has a modular architecture that allows you to use only the modules you need so that your app can stay as slick as possible. Vert.x is an ideal choice if you want to build lightweight, highly scalable microservices.

Wicket: Component-based web application framework for purists

Wicket is a component-based web application framework similar to JavaServer Faces and Tapestry. It allows you to write elegant, user-friendly apps using pure Java and HTML code. The framework is maintained by the Apache Software Foundation, just like Struts and Tapestry.

As Wicket is a component-based framework, Wicket apps are made up of reusable pages and components such as images, buttons, links, forms, and others. Programming a Wicket app centers around POJOs, therefore components are also ordinary Java objects with object-oriented features such as encapsulation and inheritance. Components are bundled as reusable packages, so you can add custom CSS and JavaScript to them.

Wicket lets you internationalize your apps, pages, and components by providing out-of-the-box support for more than 25 languages. Its built-in Ajax functionality allows you to update parts of your page in real-time, without requiring you to write any JavaScript code. Wicket pays attention to secure URL handling as well. Component paths are session-relative, and URLs don’t reveal any sensitive information. If you want to see how Wicket works in real life, check out the Built with Apache Wicket blog where you can see some nice examples.

Conclusion

When it comes to Java frameworks, keep an open mind and research which one is best for you. There are so many frameworks that will suit your project, so use this guide to assess your needs.

Raygun crash reporting and error monitoring is easily available with raygun4java. Raygun4java is a library that you can easily add to your Java application, which will then allow you to transmit all exceptions to your Raygun dashboard. Installation is painless, and configuring your site to transmit errors takes only 5 minutes. Sign up for a free 14-day trial.

Performance Matters

The best software performance articles from around the web delivered to your inbox each week.

Your information is safe with us. Read our privacy policy.

Most Popular Java Web Frameworks in 2020

July 23rd, 2020 • By Vince Power

As Java has evolved over the years, multiple attempts have been made to simplify development for various use cases. From official standards like Java Enterprise Edition, to community-driven frameworks, Java is continuing to prove itself to be adaptable and viable.

Our top list is based on usage from Hotframework.com’s Java ranking and several other sources including blog posts and GitHub download numbers.

The most popular Java web frameworks are:

Java Frameworks that are popular but not for the Web (We don’t want to forget them):

Spring is more than just a web framework. It is a complete programming model that is built on and with Java, starting with Spring Boot, which is a way to get a spring application up and running with minimal configuration and no application server required. At the other end of the spectrum is Spring Cloud, which is a combination of components that allows developers to build resilient and reliable cloud-native applications that leverage the latest distributed patterns like a microservices architecture — two examples include application security and batch processing.

There are many use cases for Spring, and with the introduction of Spring Boot, it is a great solution for companies that are moving towards containers as it greatly simplifies the components required to support the running application.

Getting started with Spring is as simple as going to Spring Initializr and selecting the build framework you desire and any and all the Spring projects you want included in the initial application. It will create the Maven or Gradle configuration and all the basic spring configuration required to start.

Creating a simple web application starting with Initializr (Figure 1):

… which will create a Zip file with the following files in it:

You need a Controller — src/main/java/com/example/demo/DemoController.java :

And a template file — src/main/resources/templates/hello.html

JSF (Java Server Faces)

JSF is a specification for displaying web user interfaces that is defined as part of the Java Platform, Enterprise Edition (JEE). JSF 1 was released in 2004, incorporated into JEE 5 and uses Java Server Pages (.jsp) as its templates. JSF 2 was released in 2009 as part of JEE 6, and leverages Facelets for templating and supports AJAX calls with a browser to allow modern web application lifecycles. JSF is component-based, allowing it to be expanded with additional components. IceFaces and MyFaces are examples of popular add-on components.

As JSF is part of the Java standard, it is popular with development teams that want to stick to published standards for increased portability across platforms. JSF also allows existing backend Java code to be extended with a web interface without having to refactor the base application by introducing a new framework.

A simple JSF application requires a Managed Bean, Facelet, and mapping the servlet.

GWT (Google Web Toolkit)

Primary Sponsor: Google

GWT is much like JSF in that it is strictly focused on building web interfaces. It is more popular than native JSF as it makes it easy to maintain complex JavaScript user interfaces with Java code. GWT has lost some of its popularity over the last couple of years as more development teams are pushing Java to the backend and having it expose REST APIs which are consumed by both native mobile apps and user interfaces built in Node.js, using frameworks like Angular.

A tutorial on how to build a simple GWT application can be found on its project site: Getting Started building a GWT app.

In summary, there are many viable Java Web Frameworks that can be used to address your needs. None of the top three are bad choices—It comes down to personal preference. Just be aware that once you commit to a framework and start to leverage its features, switching to another framework is not an insignificant amount of work.

If you haven’t already, signup for a 14-day free trial of Rollbar and let us help you take control of impactful Java errors. 🙂

Веб-фреймворки Java

Я осматривался, чтобы увидеть, есть ли эквивалент django / RoR на java.

Я нашел:

Кто-нибудь когда-нибудь пробовал эти фреймворки или вы знаете какие-то другие?
Они быстрее, чем django/RoR?


18 ответов

Я не знаю о структуре игры, но ответить на второй вопрос,
мы делаем некоторые проекты с Google Webtoolkit .
Может стоит проверить.
Удачи!

Я не знаю о Play Framework, но Spring MVC или Struts together will Hibernate предложит подобную функциональность.

Есть много других вариантов. В основном вам нужна платформа MVC (Spring MVC, Struts, Wicket) и инструмент ORM (Hibernate, iBatis). Конечно, вам нужно было бы интегрировать необходимые компоненты самостоятельно, но это было сделано уже много раз, и вы сможете найти много информации.

Я не уверен, что Spring MVC и Hibernate обеспечивают ту же простоту использования, что и Ruby on Rails (на самом деле, я уверен, что это гораздо сложнее…).
Play Framework гораздо больше похож на Ruby on Rails я думаю, однако я не делал это сам и только смотрел скринкаст и читал некоторую документацию по нему, поэтому, если вы хотите иметь подобный опыт разработки с использованием RoR, я думаю, что вы можете лучше попробовать что-то вроде Play вместо Spring MVC с Hibernate. Преимущество последней в том, что она очень мощная и способна адаптироваться к существующей модели данных, например (из того, что я знаю о RoR, это не очень тривиально в RoR).
Другой фреймворк, который вы можете рассмотреть, — Groovy on Grails. Хотя он не использует Java (он использует Groovy), он очень похож на RoR. Он использует Spring и Hibernate под капотом (если я прав), и преимущество Groovy заключается в том, что у вас нет строгого статического ввода Java.
Ruby on Rails и Django сильно выигрывают от динамической природы языка, в котором он реализован, функция Java пропускает из-за ее статического ввода.

Edit: Ах, вы уже упоминали граали в вашем вопросе…

если grails является опцией (которая на самом деле является не java, а groovy framework), то платформа лифта на основе Scala также будет опцией.

Не пробовал сам, но колледжам нравится использовать полосы

Есть книга и все такое.

Другой вариант-RIFE, который пытается иметь минимальную конфигурацию RoR, все еще находясь в Java. В вашем списке только Play Framework имеет эту функцию, другие находятся на JVM, но не являются Java (если это важно для вас вообще).

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

Что насчет VRaptor ? — он использует весну как контейнер DI и двигатель регулятора/взгляда подобный к Action-Pack рельсов.

Используя распорки, калитку, рельсы и гобелен, я рекомендую вам заглянуть в гобелен 5 .

  • в контейнере класс перезагрузки (так что вам не придется перезапускать веб-приложение каждый раз, когда вы делаете изменение)
  • быстрое время разработки & увеличенная урожайность — оно использует компонентную основанную модель, с декларативной проводкой
  • минимальная конфигурация, которая в основном в коде в любом случае, соглашение над config — etc..
  • Нет базовых классов для расширения
  • Язык выражений для использования в файлах шаблонов
  • хорошая поддержка ajax
  • превосходная поддержка отладки, и клиент и сторона сервера
  • хорошая интеграция доступа к данным
  • активное сообщество
  • написано с нуля с учетом производительности. например, объединение страниц (для минимизации использования ресурсов), сжатие страниц, устранение пробелов, весь динамический код компилируется в машинный код.
  • good bean and form support — упрощение общих задач. Сортируемая база данных с поддержкой drid может быть закодирована только одной строкой кода шаблона и минимальным скелетом серверной части.

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

(Кроме того,обязательно смотрите только на T5 — а не на T4,3,2, 1….. так как они сильно отличаются от текущей версии)

Подробнее о том, почему здесь .

Я обнаружил граали около года назад и не оглядывался назад. Он берет много идей от Ruby on Rails (первоначально он назывался Groovy on Rails) и имеет богатую экосистему плагинов / расширений. Grails, и лежащий в основе Grails язык (superset Java) делают его радостью для программирования — вы можете действительно сосредоточиться на главном. Его функциональность GORM (слой поверх hibernate) также очень мощная, и в дополнение к системе плагинов, является одной из двух огромных причин, чтобы проверить его (вы можете использовать его в своих приложениях java).

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

Что касается производительности, она определенно меньше, чем у pure Java, но у вас есть все, от spring / hibernate / J2EE, доступных вам для оптимизации, и вы всегда можете перейти на pure java для некоторых критических частей кода. В последнее время были проведены некоторые эксперименты с возможностью запуска части кода Groovy с использованием статического разрешения метода, которое в сочетании с поддержкой invokedynamic должно обеспечить огромные повышения производительности.

Другие, чтобы проверить в Java, являются Spring Roo и AribaWeb.

Обновление на основе дополнительных квалификаций

Масштабируемость, Производительность,
Документация и достойные ресурсы
потребление

  • Масштабируемость-вы получаете проверенный стек Java / Spring / Hibernate, хотя я не могу сказать, что Grails обеспечивает себя.
  • Производительность-это основная причина использования Граалей. У вас есть издержки производительности, но граали-это то, что вы используете, когда время разработки / производительность более важны.
  • Документация-Grails docs великолепны, и есть по крайней мере три хорошие книги, написанные только на Grails. Сообщество процветает и очень полезно.
  • Потребление ресурсов-это один компромисс. Grails (частично из-за базового стека java) является ресурсоемким. Если бы я строил что-то вроде Google, Grails не был бы выбором. Однако, в любом веб-приложении любой сложности, вы хорошо справитесь с решением кэширования, так же применимо и здесь.

Spring Roo утверждает, что это решение.

Попробуйте Lift Framework . Это действительно здорово.

AribaWeb также поддерживает Groovy. Проверьте наши другие функции на http://aribaweb.org/ и узнайте наш подход к тому, чтобы сделать веб-разработку продуктивной.

В любое время вы рассматриваете стек приложений (язык, фреймворк и т.д…) вы также должны рассмотреть, что вы пытаетесь решить для и какие навыки программирования у вас есть в вашем распоряжении. Я обнаружил, что более опытные Java-программисты были очень продуктивны с Groovy и Grails stack по сравнению с более младшими программистами.

Вы упомянули следующие области, вызывающие озабоченность:

  • Масштабируемость: с точки зрения чего именно? (просмотры страниц / секунда, # транзакции / секунда и т.д…) В целом, Groovy & Grails будет масштабироваться, когда дело доходит до рендеринга страниц, однако, как и с любым стеком приложений, использующим ORM (в случае Grails у вас есть GORM), есть некоторые накладные расходы, чтобы рассмотреть.
  • Производительность: одно из основных преимуществ здесь — быстрое прототипирование, быстрое развитие-это бриз с Groovy & Grails, хотя это помогает людям в штате, которые разработали на Java или Ruby, понять, что на самом деле делает Grails framework «под капотом». Есть тонны плагинов для пользовательского интерфейса, которые помогают создавать веб-2.0-подобные страницы очень быстро.
  • Документация: все большее количество качественных справочников пишется для Groovy & Grails. Оба созревают очень хорошо за последние 2 года. Вещи, конечно, не очень хорошо документированы в отношении большей части внутренней работы структуры Grails, когда встречаются ошибки/проблемы (большая часть выходных данных из структуры неясна или не существует в лучшем случае, когда ошибка сталкивается). Если вы готовы засучить рукава и быть находчивым в прохождении через внутренние работы, то вы не будете разочарованы этим стеком. Опять же, опытные программисты найдут это второй натурой, в то время как более молодые люди могут время от времени поднимать руки в разочаровании.
  • Потребление ресурсов: есть накладные расходы, однако с большинством оборудования, найденного сегодня (локальное или в облаке), я бы не слишком беспокоился о физическом потреблении ресурсов для данного экземпляра приложения.

Надеюсь, это поможет.

Мы используем рамки нашивок обширно и оно работает действительно большой. Это действительно легкий и он направляет вас к чистому дизайну ваших приложений. Он в основном просто скрывает от вас скучные части разработки, поэтому вы можете сосредоточиться на забавных вещах (один из таких примеров-индексированные свойства ).

Я сделал проект с grails, и я нашел его очень быстро для некоторых задач, но он делает много «магии» за кулисами, что затрудняет отладку.

Кроме того, я обнаружил, что читаю снова и снова документацию, потому что я не чувствовал ее естественной. Простой пример-контроллер, в котором действия определяются как поля (для меня естественно думать о действии как о методе…). Я могу сказать кое-что о GORM, где вам нужно знать некоторые специальные слова, которые, когда помещены в статические поля, делают какую-то магию, например, делают поле переходным… Нет аннотаций, нет автокомплектации… только руководство.

Что касается игры! Я нашел его удивительно простым и быстрым для развития, легко учиться и помнить. Сообщество кажется меньше, чем у Grail, но оно активнее и быстрее отвечает. Единственным недостатком является то, что он не зависит от api сервлета, поэтому некоторые сторонние фильтры или другие вещи трудно интегрировать, но не невозможно. Важно отметить, что вы можете развернуть приложение Play в любом традиционном пакете веб-серверов в it as a war.

На мой взгляд, Grails это здорово, но вам нужно иметь большой опыт работы с ним, чтобы быть продуктивным, иначе вы потеряете много времени с руководствами. Так что если это не ваш случай, я должен рекомендовать играть! Особенно если вы не знакомы с Groovy

Java web-фреймворки

Итак, сначала я хотел бы уточнить про то концептуальное различие между этими фреймворками, которое я имел ввиду. Оба этих фреймворка реализуют паттерн MVC, но немного по разному. JSF — фреймворк, ориентированный на работу с компонентами. С точки зрения разработчика это должно выглядеть примерно так — вы создаете представление (веб-страницу), пусть это будет XML страница созданная с использованием технологии Facelets. Когда вы работаете со страницей, вы представляете себе страницу набором компонент, которые во многом уже готовы для использования — кнопок, таблиц, всплывающих сообщений и пр. К определенным действиям пользователя — нажатие на кнопку и т.п., «привязаны» события в классе (backed bean), связанным с данным представлением. Данные на вашей странице также привязаны к данным этого класса. Вопрос, каким образом действия на веб-странице привязаны к методам класса в значительной мере абстрагирован. Для примера: у вас есть на странице указание (action = . ), какой метод класса нужно выполнить при нажатии пользователем на конкретную кнопку. Или: значение конкретного поля ввода привязывается к какому-то полю класса. Примерно вписать в модель MVC это можно так — страница это представление, модель данных это класс, а контроллер «скрыт» от программиста (возможно не все согласятся с таким определением, но мне оно кажется вполне подходящим в данном случае). С другой стороны, у backed bean есть обязанности, присущие контроллеру. Компоненты как правило представляют собой нечто готовое, при работе с JSF зачастую вам не нужно использовать HTML в чистом виде (и Javasсript), для этого используются определенный язык разметки и библиотеки компонентов — PrimeFaces, RichFaces, IceFaces и другие. С помощью них вы можете за несколько строчек кода сделать всплывающее окно, форму для загрузки файлов и прочее. Когда вы работаете с JSF, HTTP запросы в значительной мере скрыты от программиста. Мне кажется, что разрабатывая на JSF, думаешь больше не как веб-разработчик, а как разработчик десктоп-приложения. Есть компоненты, действия, события, а о том что здесь например нужно сделать Ajax запрос — позаботится фреймворк, для программиста — это лишь пара тегов, которые представляют собой некий «компонент, который добавит сюда Ajax». Точно могу сказать, что разрабатывая на JSF и используя Ajax, можно не знать что такое Ajax вообще. Или то, что в таком-то месте — sumbit формы. HTML и Javascript «генерируются» фреймворком. Итак, это фреймворк, ориентированный на использование компонентов, его подход более привычен для разработчиков традиционных, а не веб-приложений. Некоторые из целей такого подхода: упрощение и ускорение процесса разработки; минимизация усилий, которые нужно потратить на верстку. Кроме того, нет необходимости знать Javascript, можно создавать веб-приложения, не написав вручную не строчки на Javascript. Правда это только в теории. Spring MVC — фреймворк, ориентированный на запросы. Например вы создаете страницу используя JSP, она представляет собой обычную веб-страницу с элементами разметки, которые реализуют некоторую логику и связывают представление с моделью данных. Здесь нет никаких компонент — в общем-то традиционная верстка, javascript: когда нужно сделать запрос, вы делаете запрос, понимая что он из себя представляет. И говоря упрощенно, запросы со страницы обрабатываются контроллерами — специальными классами. Разрабатывая с помощью Spring MVC вы думаете как веб-разработчик, понятиями веба. Мне кажется Spring MVC более четко реализует паттерн MVC. Представления, контроллеры и данные строго разделены и полностью подвластны программисту. HTTP запросы полностью во власти программиста. Отмечу, что для сравнения я подразумеваю типичные ситуации при использовании данных фреймворков — использование в качестве технологий представления Facelets для JSF и JSP для Spring MVC.

Преимущества и недостатки — JSF.

К плюсам JSF можно отнести то, что это определенный стандарт, это технология для разработки веб-приложений на Java по умолчанию. Это следует из спецификаций Java EE. А значит — широкая поддержка этой технологии разработчиками спецификаций, поставщиками ПО.JSF действительно может ускорить процесс веб-разработки, особенно когда не требуется чего-то нетривиального. Не обязательно тратить много времени на верстку, более того, необязательно быть «настоящим» веб-разработчиком, чтобы создавать нечто рабочее на JSF. По задумке, можно сосредоточиться на бизнес логике. Поддержка Ajax в JSF разумеется замечательна — достаточно написать пару тегов. Доступно много библиотек компонентов, с помощью которых, не вникая очень глубоко в технические детали веб-разработки, можно создавать красивый и удобный интерфейс. И если честно, я плюсов больше не вижу. Более того, даже эти плюсы зачастую аннулируются минусами. Пойдем по порядку. JSF это стандарт. Но наверное почти никто не использует фреймворк JSF без всяческих библиотек компонентов (PrimeFaces etc.), а они не представляют из себя никакого стандарта. Я сталкивался с ситуацией, когда из-за выпуска новой версии одной такой библиотеки пришлось потратить много времени на обновление библиотеки. Так как в новой библиотеке были изменены даже некоторые названия тегов (!). Если у вас приложение, в котором есть древняя библиотека компонентов, готовьтесь к тому, что есть вероятность существенной траты времени, или, если приложение действительно большое — попадете в сущий кошмар. По поводу этих библиотек и вообще компонентного подхода. Это плохой подход. Сейчас я скажу, почему я так считаю. Во первых, то что описано выше — про стандартизацию. Ведь никто не будет менять названия HTML тегов каждые пол-года? В Javascript не появились классы и он не изменил свой синтаксис за последние 3 месяца? Это было бы полным бредом, но подобный бред реален при использовании сторонних библиотек компонентов JSF. А уйти с них бывает уже поздно — вы уже зависите от них. Да, компонентный подход упрощает в какой-то мере разработку, но веб не работает как десктоп. Разрабатывая веб-приложение нужно понимать как работает веб и управлять HTTP запросами. При подходе «по умолчанию» данные с клиентской страницы отправляются и сохраняются в объекте, который существует, пока существует HTTP сессия (это упрощенно, в JSF есть различные варианты, но во многих случаях делают именно так). Когда в веб-приложение вводится понятие сохранения состояния на стороне сервера, это усложняет механизм взаимодействия клиент-сервер и этот механизм во многом скрыт от разработчика на JSF. Это усложнение может приводить к неочевидным ошибкам. Иногда это приводит к тому, что ресурсы сервера используются неэффективно. Простая работа с Ajax это хорошо, но это приводит к тому, что ajax используется там где это совершенно не нужно. Кроме того, по умолчанию JSF использует POST запросы для всего, что можно. А как известно — POST запрос выполняется за более длительное время, чем GET, так как POST выполняется в «два захода». Предположим, у вас есть страница со множеством элементов, чуть ли не на каждую кнопку, на выбор элемента, на наведение указателя мыши «повешен аякс», все это генерирует POST. Нет ничего удивительного, что все это будет работать не очень быстро. Тот факт, что HTML код и Javascript генерируется JSF, за счет использования готовых компонентов, иногда приводит к неочевидным ошибкам. И иногда, для того, чтобы исправить эту ошибку уйдет уйма времени, особенно если вы плохо разбираетесь в Javascript и в том, как работает JSF «внутри». Итак, знание Javascript в той или иной мере обязательно и здесь (что естественно). Код большой страницы, который генерируется JSF, может привести в шок «нормального» веб-разработчика, если у него хватит терпения разобраться в «спагетти-коде». Если вам нужно сделать что-то необычное, что нельзя сделать с помощью готовых компонент — вам нужно в любом случае знать Javascript, и более того — как это привязать к тому сделано на JSF. Иногда нужно проявлять «чудеса изобретательности» чтобы сделать что-то необычное. При работе с JSF в итоге придется изучить много вещей, специфичных для JSF. Это как некая «параллельная» веб-разработка. Это аннулирует всю простоту и удобство JSF на первых этапах, если приложение простое. Если вы начинающий разработчик JSF, который раньше не занимался веб-разработкой, вы будете думать другими категориями, будете изучать другие технологии, у вас будут на слуху другие вещи. Вы будете отрезаны от сообщества веб-разработчиков, потому что вам не нужно знать как сделать Ajax запрос с помощью JQurey, зато вам нужны узкоспециализированные знания и технологии. О которых большинство веб-разработчиков вообще ничего не слышали. И как я уже говорил выше — эти технологии иногда специфичны и могут быстро меняться.

Недостатки и преимущества — Spring MVC.

К преимуществам Spring MVC определенно можно отнести саму концепцию, ориентированность на запросы. Когда разработчик четко понимает, какие запросы и куда отправляются со стороны клиента, это приводит к более рациональному проектированию приложения. К более оптимизированному и быстрому коду. Вероятность неочевидных ошибок, с которыми приходится сталкиваться в работе с JSF, минимальна. Поддерживать приложение на Spring MVC проще, потому что все более прозрачно. Не нужно гадать, почему например не открывается всплывающее сообщение, хотя по всем законам логики оно должно открываться (это JSF). Если используется JSP, то это означает, что никакого сгенерированного Javascript кода не будет. Вся верстка делается обычным образом, визуальные компоненты тоже создаются «традиционным» способом. По умолчанию, контроллеры Spring MVC не сохраняют состояние страницы на стороне сервера, эти классы представляют собой паттерн «одиночка». По моему мнению, не смотря на то, что JSF — стандарт, у Spring MVC более высокий уровень стандартизации. Никакой зависимости от сторонних библиотек компонентов. Для создания визуальных компонентов и реализации определенной логики можно использовать известные всем веб-разработчикам библиотеки — например JQuery, Twitter Bootstrap и пр. Мне кажется что эти библиотеки, которые используются очень широко — их можно назвать стандартом, в отличие от библиотек компонентов JSF, которые часто сами используют JQuery и являются «дополнительно прослойкой». Используя Spring MVC придется в обязательном порядке писать вручную Javascript, что мне кажется плюсом и вполне логичной вещью. Любой веб-разработчик должен быть знаком с Javascript, а при работе с JSF это отрицается, но на практике незнание Javascript не приводит ни к чему хорошему. Знания, которые нужно иметь при работе с Spring MVC более общие для всех веб-разработчиков, если говорить о клиентской стороне приложения (интерфейсе). Таким образом вы не отрезаете себя от огромного сообщества. Могу отметить, что когда я столкнулся с Spring MVC я очень быстро решал все проблемы и возникавшие ошибки, даже на первоначальном этапе. В целом Spring MVC гораздо более «прозрачен» для понимания и изучения. К минусам по сравнению с JSF можно отнести разумеется то, что придется потратить больше времени на верстку. Что компенсируется меньшими усилиями при дальнейшей поддержке системы. И что в итоге? Все то, что я написал выше — просто мое мнение, основанное на практическом опыте работы с этими фреймворками. Я не считаю что JSF не нужно использовать всегда, я просто хочу сказать, что если вы решили сделать выбор в пользу JSF для своего проекта — еще раз взвесьте все минусы и плюсы. Иногда, JSF при первом взгляде кажется просто находкой и замечательной вещью, но это не совсем так. Мне кажется что рационально выбрать JSF для разработки системы не ориентированной на веб, а ориентированной на работу в локальной сети. Например какая-нибудь внутренняя система предприятия. Я считаю что JSF малопригоден для веба по причине нагрузки, которую он создает на сеть и его производительности в целом. Если это веб-приложение не будет содержать в себе чего-то необычного, допустим это какая-нибудь система управления бухгалтерской отчетностью, которая с точки зрения UI тривиальна. И если нужно сделать эту систему в наиболее краткие сроки, можно брать готовые компоненты, и не беспокоиться по поводу дизайна. Тогда вполне можно выбирать JSF. Я думаю, что Spring MVC в целом является в большинстве случаев хорошим выбором, исключение разве что вышеописанная ситуация, когда рационально выбрать JSF. Если нужно создать нетривиальный интерфейс, веб-приложение которое будет работать действительно быстро, в интернет — тогда Spring MVC выигрывает на 100 %.

Веб-фреймворки Java

Я смотрел вокруг, чтобы увидеть, есть ли эквивалент django/RoR в java.

Я нашел:

Кто-нибудь когда-либо пробовал эти рамки, или вы знаете другого? Являются ли они быстрее, чем django/RoR?

Я обнаружил Грайля около года назад и не оглянулся назад. Для Ruby on Rails требуется много идей (оригинал был назван Groovy on Rails) и имеет богатые экосистемы плагинов/расширений. Grails и базовый язык Grails (надмножество Java) дают радость программе — вы действительно можете сосредоточиться на сути. Его функциональность GORM (слой поверх гибернации) также очень эффективна, и в дополнение к плагиновой системе это одна из двух огромных причин, чтобы проверить ее (вы можете использовать ее и в своих приложениях Java).

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

Что касается производительности, то это определенно меньше, чем у чистой Java, но у вас есть все, что вам нужно, от spring/hibernate/J2EE, которое вы можете оптимизировать, и вы всегда можете отказаться от чистой java для некоторых критических фрагментов кода. Были некоторые недавние эксперименты, позволяющие запускать часть кода Groovy, используя разрешение статического метода, которое в сочетании с поддержкой invokedynamic должно обеспечивать огромное повышение производительности.

Другие, чтобы проверить на Java, — это spring Roo и AribaWeb.

Обновление на основе дополнительных квалификаций

Масштабируемость, производительность, Документация и достойные ресурсы Потребление

  • Масштабируемость — вы получаете проверенный стек Java/ spring/Hibernate, хотя я не могу сказать, что Grails очень много.
  • Производительность — это основная причина использования Grails. У вас есть накладные расходы, но Grails — это то, что вы используете, когда время разработки/производительность важнее.
  • Документация — документы grails великолепны, и есть только три хорошие книги, написанные только на Grails. Сообщество процветает и очень полезно.
  • Потребление ресурсов — это единственный компромисс. Grails (частично из-за базового пакета Java) ресурсоемкий. Если бы я строил что-то вроде Google, Grails не был бы выбором. Тем не менее, в любом веб-приложении любой сложности вы бы сделали все возможное для решения кэширования, так же, как и здесь.

Stripes кажется довольно легким и охватывает Конвенцию по конфигурации.

Используя стойки, калитки, рельсы и гобелен, я рекомендую вам заглянуть в Гобелен 5.

  • в перезагрузке класса контейнера (поэтому вам не нужно перезапускать ваш webapp каждый раз, когда вы вносите изменения)
  • быстрое время разработки и повышенная производительность — в нем используется компонентная модель с декларативной проводкой
  • минимальная конфигурация, которая в основном используется в коде, соглашение по config — и т.д.
  • Нет базовых классов для расширения
  • Язык выражения для использования в файлах шаблонов
  • хорошая поддержка ajax
  • отличная поддержка отладки, как на стороне клиента, так и на стороне сервера.
  • хорошая интеграция с доступом к данным
  • активное сообщество
  • написанный с нуля с производительность. например пул страниц (для минимизации использования ресурсов), сжатие страницы, устранение пробелов, весь динамический код скомпилирован в native.
  • good bean и поддержка формы — упрощение простых задач. Сортируемая база данных, поддерживаемая drid, может быть закодирована только с одной строкой кода шаблона и с минимальным бэкэндом сервера скелета.

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

(Кроме того, обязательно смотрите только T5 — и не T4,3,2,1. поскольку они сильно отличаются от текущей версии)

Подробнее о том, почему здесь.

Рассмотрим пример Подъемная платформа. Это действительно здорово.

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

Вы упомянули следующие проблемы:

  • Масштабируемость: с точки зрения того, что именно? (просмотры страниц/секунды, # транзакций/секунд и т.д.). В общем, Groovy и Grails будут масштабироваться, когда дело доходит до страниц рендеринга, как и любой стек приложения с использованием ORM (в случае с Grails у вас есть GORM ) есть некоторые накладные расходы, чтобы рассмотреть.
  • Производительность: одно из основных преимуществ здесь: быстрое прототипирование, быстрое развитие — легкий ветерок с Groovy и Grails, хотя он помогает людям на основе Java, разработанным на Java или Ruby, понять, что на самом деле представляет собой инфраструктура Grails делая «под капотом». Существует множество плагинов для пользовательского интерфейса, которые очень быстро помогают создавать веб-страницы, похожие на веб-страницы.
  • Документация: все больше качественных справочников написано для Groovy и Grails. Оба созревают очень хорошо за последние 2 года. Вещи, конечно, не очень хорошо документированы в отношении большей части внутренней работы структуры Grails, когда встречаются ошибки/проблемы (большая часть выходных данных из структуры неясна или вообще не существует в лучшем случае, когда возникает ошибка). Если вы готовы засучить рукава и быть находчивыми, прогуливаясь по внутренней работе, то вы не будете разочарованы этим стеком. Опять же, опытные программисты найдут это как вторую природу, в то время как более молодые люди могут время от времени рвать свои руки.
  • Потребление ресурсов: есть накладные расходы, однако с большинством оборудования, найденного сегодня (локальным или в облаке), я бы не стал слишком беспокоиться о потреблении физических ресурсов для данного экземпляра приложения.

Java web-framework


Подскажите, какой веб-фреймворк для Java сейчас считается хорошим?

Цель — веб-приложение. НЕ обычный информационный сайт, а сложная софтина, с вебом имеющая только то отношение, что ее морда будет работать в браузере.

Т,е. от веб-фреймвока целиком не_нужно средства по упрощению быдлокодинга тонн веб-страничек, там страничек будет всего несколько штук, да и те все абсолютно разные. Не нужно генерации JS типа Vaadin: жаваскрипта у нас будет самый минимум, а тот что есть — мы можем и должны будем написать руками. Не нужны новомодные активные клиенты — гуй должен в том числе показываться на стрёмных-стрёмных телефонах, то есть это чистый HTML.

А нужны правильные архитектурные, конкуррентные и прочие server-only фичи, держа в голове что это всё-таки веб.

Сейчас команда чуть не стала использовать Apache Wicket «с разгону» потому что конкуренты так делают. Но мне кажется, что Wicket — это такой монолитный кусок legacy-ужаса, пришедший к нам из глубин тёмных веков.

Во-первых, вопрос, действительно ли так, или мои суждения искажены и я несправедливо заклеймил Викет говном?

Во-вторых, собственно, если не Wicket, то что?

Напрашиваются лидеры гугла: Spring и Play Framework for Java.

Насчет Плея, он ведь изначально сделан как раз для информационных сайтов. Насколько он нужен в контексте описанной выше цели? Насколько он хорош в Java-версии?

Насчет Спринга — он необъятен, какие части инфраструктуры стоит вкурить в самую первую очередь? Есть нечто более хорошее, чем Spring MVC?

Сделать жизнь лучше, не используя веб-фреймворки Java? [закрытый]

Я так устал от того, чтобы изучать еще один веб-фреймворк Java через день.
JSP, стойки, калитка, JSF, JBoss шов, Spring MVC, чтобы назвать только несколько — все это бесчисленные рамки там пытаются решить те же проблемы. Однако ни одна из них по — настоящему не решает фундаментальных проблем-поэтому все время появляются все новые и новые.

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

короче говоря, я вижу следующие недостатки при использовании фреймворка:

  1. в основном есть крутая кривая обучения, и вам сначала нужно понять иногда довольно академические понятия и знать значение и расположение кучу файлов конфигурации, прежде чем вы можете начать работу.
  2. документация обычно более или менее ужасна, либо отсутствует общедоступная онлайн-ссылка, беспомощно устарела, путает разные несовместимые версии или все это вместе и часто не дает никаких полезных примеров.
  3. структура состоит из миллиардов классов, что делает его практически невозможным для понимания назначение только при просмотре источников.
  4. поэтому вам нужно купить некоторые» XYZ в действии для чайников в 21 день » вид книг, которые имеют плохой пользовательский интерфейс, потому что они не хватает полнотекстового поиска и тяжело носить с собой.
  5. чтобы действительно использовать один из этих фреймворков, вам нужно выучить наизусть, как все можно сделать так, как этого требует фреймворк, запоминая адекватные классы и имена методов, пока ваша голова не будет полна глупых и бесполезных информацию нельзя использовать ни для чего другого.
  6. есть большие накладные расходы, замедляющие производительность приложений и заставляющие ваш мозг чувствовать онемение, когда вы пытаетесь понять, что на самом деле происходит.
  7. в реальном мире обычно нет времени, чтобы хорошо ознакомиться с чем-то новым из-за давления продуктивности. В результате этого обучения, делая подход, всегда ищут только самый быстрый способ выполнить следующую задачу, а не на самом деле понимание нового инструмента и его возможностей.
  8. аргумент, что следование стандарту позволит людям, которые являются новыми для проекта, быстро начать работу, на мой взгляд, недействителен, потому что каждый проект использует другую структуру даже в одной и той же компании (по крайней мере, в моем случае).

Мне кажется, что здесь очень хорошо подходит следующая цитата из Альберта Эйнштейна:

«мы не можем решить проблемы, используя тот же тип мышления мы использовали их, когда создавали.»

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

Так почему все эти хлопоты с использованием этих рамок, почему бы не выбросить их все и вернуться к корням?
Что мне сказать боссу, когда мы начнем? завтра очередной проект с новыми рамками?
Или, может быть, есть рамки, которые действительно имеют значение?
Или какие-то скрытые преимущества, которые я проигнорировал?

13 ответов

назад в мои старые добрые дни кодирования PHP Когда кодирование еще было весело и продуктивно, я писал свои собственные рамки для большинства вещей и просто copy-pasted и принял их от одного проект к следующему. Этот подход выплачивается очень хорошо, в результате чего быстро развития, отсутствие накладных расходов на всех и рамки, которые на самом деле были мощнее чем большинство фреймворков Java там

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

но только с несколькими сотнями строк код в одном файле плюс несколько простых правила mod_rewrite. Это, конечно, не решал все проблемы web развитие, но оно было простым, быстрым и сразу к делу.

и все же вы не можете понять, почему другие делают то же самое а затем попытаться превратить результат во что-то полезное для всех?

где этот великий Framework вы разработали? Если он настолько мощный и простой в использовании, где выделенные сообщества, тысячи пользователей и сотни сайтов, разработанных с ним?

каждый проект использует другой рамок даже в пределах одной компании (по крайней мере в моем случае)

Ну, это твоя проблема. Зачем тебе выбрасывать приобретенный опыт? с каждым фреймворком после каждого проекта?

идея состоит в том, чтобы выбрать один фреймворк и придерживаться его над несколькими проектами, чтобы вы могли овладеть им. Вы должны потратить некоторое время на изучение фреймворка, а затем он экономит ваше время, позволяя вам работать на более высоком уровне.

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

просто спросите Джеффа и ребят о том, что они должны были учитывать при реализации WMD в Stack overflow. Я бы предпочел использовать то, что они создали в проекте, а не реализовывать его с нуля. Это только один пример.

проблема конечно не только с Java фреймворков. Я потерял счет количеству проектов c++ MFC, которые я видел, барахтаясь, пытаясь обувать свои требования в модель документа/представления (которая действительно работает только для текстовых и графических редакторов — приложения базы данных особенно трудно обувать).

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

вот цитата из Кев из потока каково ваше самое противоречивое мнение о программировании? который подходит здесь очень хорошо:

Я думаю, что вся» корпоративная » вещь-это дым и зеркала. J2EE, .NET, большинство фреймворков Apache и большинство абстракций для управления такими вещами создают гораздо большую сложность, чем они решают.

Возьмите любой обычный Java или .NET OMR или любой предположительно современный MVC рамки для того, что делает «магию» для решения утомительных, простых задач. В конечном итоге вы пишете огромное количество уродливых шаблонов XML, которые трудно проверить и быстро написать. У вас есть массивные API, где половина из них просто интегрирует работу других API, интерфейсов, которые невозможно переработать, и абстрактных классов, которые необходимы только для преодоления негибкости Java и C#. Нам просто не нужна большая часть этого.

Как насчет всех различных приложений серверы с их собственным проклятым синтаксисом дескриптора, чрезмерно сложной базой данных и продуктами групповой работы?

дело не в том, что сложность= = плохо, это то, что ненужная сложность==плохо. Я работал в массивных корпоративных установках, где некоторые из них были необходимы, но даже в большинстве случаев несколько домашних сценариев и простой веб-интерфейс-это все, что нужно для решения большинства случаев использования.

Я бы попытался заменить все эти приложения enterprisey на простой веб фреймворки, DBs с открытым исходным кодом и тривиальные конструкции программирования.

Так вы говорите, что мы должны иметь дело с сокетами и HTTP каждый раз, когда мы хотим создать веб-приложение!

сам контейнер сервлетов можно считать фреймворком, так как он обрабатывает все эти грязные детали и оставляет вас писать гораздо более простые сервлеты/фильтры/прослушиватели (т. е. «расширения» фреймворка, специфичные для вашего приложения).

все, что любой фреймворк пытается сделать, это отделить приземленный, повторяющийся, подверженный ошибкам, код legwork от удовольствия код конкретного приложения.

однако, для небольшого приложения, вы можете уйти с просто модель 2 MVC подход, который использует только JSPs и сервлеты.

затем, когда ваше приложение становится более сложным, вы можете посмотреть на использование Spring MVC для обеспечения более свободной связи (и, следовательно, более гибкой) контроллеров, резольверов и т. д..

Я разделяю вашу боль, когда сталкиваюсь с еще одной структурой, которая не делает трюк.

пережив десять лет jsp, struts, EJB, EJB2, struts2, jsf и теперь совсем недавно все новые веб-сервисы framworks, ужасы xslt и кошмары WSDL-first, я определенно сыт по горло.

Существует ряд проблем с рамками. Они!—5утечка таким образом, вы должны узнать больше-не меньше, внутренние рамки имеют огромные затраты, используя внешние рамки затраты тоже (но гораздо меньше), так как они редко доставляют, а затем вы в конечном итоге пишете enourmus куски xml-конфигурации и проводите дни, исправляя регистр и орфографические ошибки, которые вы сразу увидели в своем любимом редакторе кода.

может быть, ответ найти менее помпезно инструменты это пытается решить проблему, но не переопределить мир, но это тоже сложно, поскольку фундаментальная модель приложения (html через http) неудобна-на лучший.

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

добавьте высокомерие разработчиков, которые знают все это и не стесняйтесь писать новую структуру, чтобы решить все сложные проблемы для вас, только то, что они не могут, оставив 10% осталось, только много теперь починить сложнее.

У меня нет опыта .NET, но мир .NET, кажется, менее переполнен теоретиками и усложнителями, и, возможно, затяжная вонь VB отпугивает их, но каждый раз, когда я слышу, что кто-то говорит мне, что они потратили 1500 часа на их конфигурации maven (привет?), Я серьезно рассматриваю возможность удаления «java» из моего резюме.

. какой был вопрос? Существуют ли какие-либо рамки, которые имеют значение?

изменить — добавлены полосы и QueryDSL.

Я бы попробовал полосы или GWT с QueryDSL + Hibernate или OpenJPA (с аннотациями) только за то, что вы на самом деле разрабатываете на Java, и стараюсь максимально ограничить использование WSDL-первых веб-сервисов, xml-ориентированных фреймворков, EJB и ESBs (а не пива).

Ну, не делает то же самое каждый день скучно.

Мне однажды пришлось работать над проектом, пытаясь реализовать его в JSF. Это был кошмар.

большая часть рабочего времени была потрачена на компиляцию. Тот факт, что не менее половины того, что было собрано, не сработало, — это другая история. Почти никаких уроков. Документация-это в основном автоматический экспорт исходного кода без комментариев человека. Как можно ожидать такой работы?

из нескольких фреймворков, которые мы видели, только Sun смог создать новый проект, который компилируется вообще! Другой мог производить только кучу вещей, потребовалось много дней, чтобы позвонить в компилируемое состояние.

поэтому мы потратили время и только сделали что-то простое, что можно было бы сделать за несколько недель с помощью ASP.NET например.

затем мы рассмотрели альтернативные фреймворки JSF. К нашему удивлению, все они оказались несовместимыми.

без удивления, мы присоединились к рядам тех, кто бросил JSF, а также.

рассмотрим точку контр. Я работаю в магазине прямо сейчас, который не использует никаких рамок за пределами стандарта JSP. У каждого есть другой способ делать вещи, и мы очень небрежны в отношении таких понятий, как де-сцепление и проблемы безопасности, такие как проверка.

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

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

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

Что сработало для меня: вы не должны просто изучать любую веб-структуру, о которой вы слышите, взглянуть на нее, посмотреть, удобно ли она делает вас кодом, спросить вокруг stackoverflow или форумов, чтобы увидеть ее преимущества и недостатки, а затем изучить ее и узнать ее хорошо и просто придерживаться ее, пока не почувствуете, что она сломана или просто устарела. Любой из веб-фреймов, о которых вы писали, хорош сам по себе и забавен, если вы «действительно» знаете, что он делает. если нет, то ты просто блуждаешь в пустыне, где нет . компас! Я также обнаружил, что книга «21 день» — это верный способ не осваивать фреймворк или технологию. Docs, безусловно, что-то рассмотреть при принятии f/w это также помогает, если вы посмотрите вокруг кода самостоятельно (на самом деле это то, что помогает мне лучше всего, когда я столкнулся с некоторым поведением, которое я нахожу wierd.

1 — так почему все эти хлопоты с использованием этих фреймворков, почему бы не выбросить их все и не вернуться к корням?

Если вернуться к корням переписать код, который делает то же самое снова и снова + большинство из этих f/ws с открытым исходным кодом означает, что они, вероятно, лучше с обслуживанием, чем вы сделали бы в одиночку с вашим собственным f/w.

2-что я должен сказать моему боссу, когда мы начинаем очередной проект с новой базы снова?

Это мой первый раз, работая с этим f/w я не вижу, почему мы должны использовать этот f/w я уже знаю X, и я действительно хорош в этом. оголите в разуме цену меня уча это f / w, стоимость переделки, которая должна быть сделана из-за моего незнания такого f/w. Я думаю, что нам лучше использовать X, если это конкретное требование, мы должны бороться за него и делать это только в том случае, если нам действительно нужно указать предыдущие заметки.

или, может быть, есть рамки, которые действительно имеют значение?

только те, кто обращается к тому, как вы думаете, а не так, как вы пишете код (думаю, struts в свой золотой век, применяя шаблон MVC).

или некоторые скрытые преимущества I проигнорировали?

Не могу придумать никакого tbh.

У вас та же проблема в PHP: больше фреймворков, чем у вас есть пальцы, чтобы сосчитать их, каждый из которых является лучшим и самым большим (хотя у вас есть некоторые подсказки: чистый дизайн PHP5 против совместимости PHP4, философия Rails (негибкая иерархия папок, автоматически сгенерированный код) против библиотечного подхода. ) и вы тратите больше времени на поиск и изучение возможностей, чем на написание кода!
Но в PHP это позволяет предварительно решить общие проблемы, такие как поддержка I18N, интеграция плагинов, управление сеансами и аутентификацией, абстракцией базы данных, шаблонами, поддержкой Ajax и др. Избегая заново изобретать колесо на каждом проекте, и попадать в общие ловушки для новичков.

конечно, есть некоторые подсказки для Java-фреймворков: большие или маленькие? хорошо документировано или нет? широко используется или конфиденциально? для поклонников XML или нет? Так далее.
Я полагаю, что большинство фреймворков нацелены на большие проекты, где время обучения не является большой проблемой, масштабируемость и простота развертывания важно, и т. д. Они, вероятно, излишни для небольших проектов.

существует также тенденция в таких рамках стремиться к созданию последовательного набора слабо связанных библиотек, а не монолитной структуры. Это так, в мире PHP, для Zend framework (некоторые даже отрицают использование слова «framework». ).
Таким образом, он решает проблему «решения общих проблем», не мешая.

Итак, вы думаете, что будет лучше, если мы все изобретем колесо в каждом проекте?

вы можете увидеть избыток фреймворков как проблему, и это затрудняет выбор вашего собственного набора. Но, с другой стороны, вам не нужно пробовать каждый из них; и даже если вы это сделаете, вы в конечном итоге предпочтете некоторые из них. У вас будет любимая платформа для ORM, другая для веб-разработки, IoC и т. д.

Это помогает читать на некоторых форумах, чтобы узнать, какие из них самые популярные; они должны быть популярны по какой-то причине, и даже если это не правильная причина (например, технически превосходящая, возможно, она популярна только среди менеджеров из-за перегрузки модных слов или что-то еще), знание указанной структуры будет полезно, потому что вы сможете участвовать в нескольких проектах, которые ее используют.

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

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

Да все веб-приложения касаются страниц, отображающих формы, сбора данных, проверки, отправки данных для хранения в базе данных и фильтрации сохраненных данных по формам поиска и отображения результата в таблицах и выбора одной или нескольких записей для манипулирования (CRUD или бизнес-действия, которые все об изменении статуса в база данных.)

однако я работаю всего 4 года плюс, конечно, мое 4-летнее академическое исследование. Я чувствую, что этот тип разработки скучен, поскольку вы не изобретаете алгоритмы, конечно, вы были счастливы, когда вы открываете новую структуру, и будете счастливее, если вы интегрируете один из двигателей ИИ в свое приложение, но в конце концов я чувствую, что эта работа-фиктивные работы или, скажем, машинная работа, поэтому мы не автоматизируем все это.

да еще один фреймворк 😉 СРЕДНЕСРОЧНАЯ ОЦЕНКА Архитектура, управляемая моделью, вкратце о преобразовании из PIM (независимая от платформы модель) в PSM (специфичная для платформы модель), i.e например, из UML в код.

и это может решить вашу проблему кривой обучения и технологических изменений, поскольку вам нужно будет только хорошо моделировать, так как есть некоторые рамки это реализует спецификации MDA, такие как AndroMDA поскольку у него есть картриджи, которые принимают диаграммы классов, варианты использования, диаграммы последовательности и Диаграммы действий и генерировать сценарий создания базы данных, POJOs, отображение спящего режима, Spring/EJB, JSF / Struts, .NET-код.

конечно, такие фреймворки не будут генерировать 100% кода, но будут генерировать большой процент, и, конечно, вы спросите, куда эта фреймворк будет решать сложные и сложные сценарии требований? сегодня я скажу «нет», завтра «да».

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

Мастер Йода рекомендует:  15 полезных команд PostgreSQL
Добавить комментарий