I have built a process using JBPM. I am evaluating building forms using form builder provided by KIE Workbench. I saw that it uses Uberfire under the hood. What are the pros and cons of using KIE workbench for building forms vs using another are UI technology (angular js etc) and integrating that with JBPM process? Also is there a way to customize the form builder module to use other UI framework such as Angular JS , if needed?
Much of the functionality to add data items to Forms was removed in early jbpm 7.x including the ability to customise pages in an useful way. I'm not sure the reasoning for the removal of functionality it could be related to the migrations from the previous platform to uberfire etc.
It is so limiting now my project has struggled to even populate a listbox with data dynamically and chaining forms together is now impossible. We may have to end up building a custom front end - which kind of defeats the purpose of the no-code solution for workflow requirements. I'm not sure how this compares with the state of the commercial redhat product.
Related
I'm going to develop a map server with my own logic and entities. It will have postgres database, user management, specific layers with certain types, WFS, WMS, etc.
I'm going to use springframework and GeoServer as the GeoServer is an open source project. My question is whether I develop it or use it as a separated server? How about the user management problem? How can I integrate my own project security with the geoserver?
Typically you develop a front end that's completely separate and have GeoServer offer the OGC services to it and other clients. In case you need to customize it, GeoServer has a fully pluggable architecture, e.g., you can build a version of it that has more or less modules than the standard one, your own security subsystem, your own custom data sources, and so on, a lot can be either configured or replaced, so I'd suggest you look into those options.
Mind one detail, GeoServer is GPL'd, so any code you develop that depends on GeoServer API will similarly be GPL'd. If instead you develop something that's only based on GeoTools (e.g., a custom data store) that part can be closed source.
I would like to know what is the relationship between Java and FatWire.
I know it is possible to create templates using JSP but does it involve any standard Java programming? Also, is it possible to integrate it with MVC frameworks such as Spring or Grails?
Fatwire (now Oracle WebCenter Sites) is a CMS system originally based on an XML language. A JSP API (with the same features of the original XML language) was added later and it became prevalent. One of the biggest drawback of this design is that most of your coding must be done in JSP (that is a view only technology). So you have the (content) model and the view but not a controller layer.
But the real problem is that either you extend the Fatwire application with Java code (restarting the application server at each change, or using JRebel) or you have to code everything in JSP. Almost the website implementation I have seen so far uses a lot of JSP and some spare java classes, so websites have the tendency to be written with the crippled java available in JSP (you cannot share a class for example, or leverage the full Java OOP).
If you want to use full Java, you may use frameworks that implements MVC. For example, AgileSites (Disclaimer: I am the main developer of AgileSites). AgileSites basically uses JSP as interface to the CMS (as the documentation recommends) but those JSPs calls java code stored in hot swappable jar, built automatically while you do your development. So you can code everything using plain Java, without having to restart the application server at each change (only the jar, that is small, is rebuilt, when you save a file). On top of this Java enabling technology, AgileSites gives you plenty of features: clean separation of presentation from controller, using pure java controllers and pure html views, embedded unit testing support, an integrated build for continuous integration, scaffolding, a very simplified API covering 80% of normal needs (while giving full access to the full API) and more.
Fatwire templates can be developed using JSP, XML and HTML. Developing it using JSP has many advantages and Fatwire comes with JSP tags (called ICS tags) for standard based development. Most commonly you can see a JSP based template containing scriptlets of Java code invoking Fatwire's asset api which is implemented in Java.
Latest addition to this is Fatwire Web Experience Management (WEM) framework which are a collection of REST services with SSO that will enable you to write applications around Fatwire.
For example, I have developed REST based applications to integrate SVN, Translation systems and provisioning systems with Fatwire using Java.
Also, the latest Fatwire (Oracle Webcenter Sites) comes with set of developer tools called CSDT which is actually a Eclipse plugin that lets you develop templates within Eclipse (that has all the good features such as versioning, syntax checking) and facilitates local development, versioning of templates and continuous integration.
Yes, Java and FatWire can be used mutually. Code your java classes, wrap them and deploy in war or jar format in your app server lib folder. While coding inside JSPs, call your java classes or methods in JSPs and use them as required.
I search for an architecture to implement an egovernment solution with java. I would like the possible solution present the following features:
Based on Java (JSF, Spring, JPA)
Modular architecture
Strongly designed around BPM
processes
Isolate workflow engine from user
task forms (in order to provide fault
tolerance)
I have found several bpm alternatives such as jBPM, Activiti, Intalio or Enhydra. By now, I like Activiti approach but I don't find a suitable solution for a modular architecture and user task forms isolation. Perhaps, a multimodule maven project (ie, one jar module per procees) or a OSGi option would fit but I don't know how to wire up all these pieces.
What would you recommend me in my quest?
Thanks very much in advance
Intalio runs the user tasks in a separate web application. It can be deployed to a different server from the runtime engine.
I think that you might be interested by the upcoming version 7 of Bonita BPM.
Engine conception is services oriented and all implementations are injected using Spring. Persistence is handle directly by Hibernate (no JPA) but make use of JTA.
Architecture is separated into three main components:
Studio: the development environment for BPMN process modeling
UI Designer: to define forms and pages that will be used for process execution as well as for applications creation. it's a custom AngularJS solution that is used here but you can as well use any alternative solution you want thanks to Engine API.
Portal: web interface for administration and end users operation.
Engine: component that actually execute the process definition build using the Studio. Engine provides a set of API available using REST or a Java client library.
The Engine is the core of the Solution and Portal is built on top of it using Engine API.
Process definition actually declare a set of contract at process and step level to define what data must be provided by the forms in order to start a new process instance or execute a task. So we have a loosely coupled design here.
We have a desktop java application (image-processing) that is working great, now we have to add a client/server architecture using Java EE plateform.
We must use also MVC, and interacting with many other libraries like JDOM, JMatlink(MATLAB), and calling some exe files.
Based on your experience what is the best choice to do that (framworks, ... )
Correct, you must use an MVC framework to design a flexible and reusable web application on the Java EE platform.
I suggest the following design:
Use JSF (Java Server Faces) to design the front end. As you are migrating your desktop application then it will better suit you becuase it's Component and Event driven framework.
Middlware: EJB 3(or EJB3.1) This will provide best available flexibility, performance and security to call your Business components directy from JSF Beans or any other remote application.
Over here you can use various design pattern to encapsulate Library and database access i.e. DAO (Data Access Object).
Use DTO (Data Transfer Objects) to transfer your request/response.
Hope it will give base to start your research.
If you can abstract the layers that talk to the backends such that your frontend (Swing?) doesn't need to know where those service are located, you are half-way there.
The key should be a good module concept. Frameworks like the NetBeans platform help you with that, and they can easily integrate non-visual modules that handle the backend code.
I'm not sure what you mean with "We must use also MVC"
MVC is a design pattern not a library or framework.
But if you use something like the NetBeans platform, you'll be applying that pattern anyway, because it forces you to think in modules. Each module will have a defined responsibility and during startup it registers itself with the application.
Take an application that allows you to manage people (e.g. for a human resource department). One module is responsible for displaying a form where the user can look at a single employee. That module in turn looks for a provider that can load or list all employees. How that provider gets the data is invisible to the front end. It could use a flat file, a relational database or a call to a remote EJB server (this is were you could plug your JavaEE stuff in)
The application could even download the modules from the server if correctly configured.
The key is to make the modules independent from each other. This is true for any large scale application regardless of the technology used (web application, a server side daemon or a desktop application)
Do you know of any tool that would do like Ruby on Rails' Scaffolding (create simple CRUD pages for any particular class to allow quickly populating a database with dummy data), only which used Java classes with Hibernate for database access, and JSP/JSF for the pages?
It is a drag when you are programming one part of an application, but need data that can only be added with another part that is not ready yet, or very cumbersomely by directly inserting it into the DB.
Grails is a very nice Rails-like framework built on top of Spring MVC. For persistence, they use GORM, which is basically an ActiveRecord-like framework built on top of Hibernate. Pretty slick.
If you already have Hibernate entities, they can actually be used immediately in Grails with no additional work.
You can try Telosys Tools, an Eclipse plugin for
code generation (scaffolding) working from an existing database
with customizable Velocity templates.
It's very simple and easy to use.
The tutorial for code generation with Spring MVC and Spring Data is here : https://sites.google.com/site/telosystutorial/
See also : http://tools.telosys.org/
Eclipse Marketplace : http://marketplace.eclipse.org/content/telosys-tools
I'm a little late on this one but it popped up in the "Related" links →
JBoss Seam and it's Seam Gen tasks are exactly what you are looking for (Hibernate + JSF). You can generate an entire web app from a Hibernate fronted database in seconds.
you can use grails. Grails tries to be Groovy on Rails -- uses Rails behind the scene for scaffolding, etc. Since you can pretty much write full scale java code in a groovy class, you can have the CAKE and EAT IT too.
Grails is somewhat different from Rails, even though it was based on Rails and has a similar feel. Grails uses spring to help wire your services together. The environment is not only dynamic (with Groovy) but also allows you to use Java (static environment) as well. It is really cool, especially if you're coming from a java environment. The Grails folks took the Rails idea and expanded it using the Domain Driven Model. Rails is still data model centric where you have to deal a lot with the database to create your objects (which is called a model), where as Grails allows you to design applications using the true domain object model where you deal with objects from the domain class' perspective instead of the database.
There is a good tutorial here on how to do this in Netbeans. I've used this wizard before with good results. Out of the box you can select which persistance framework to use and the JSF pages it produces are quite nice and clean.
Spring + AspectJ + Hibernate + CLI = Spring Roo RAD framework.
Give it a try.