The document provides a comprehensive overview of JHipster, a development platform that combines Spring Boot and AngularJS to create modern web applications. It covers installation, application generation, client and server-side frameworks, as well as advanced features and tools for developers including database support, security options, testing, and deployment methods. Key highlights include entity creation, Docker integration, and management of application environments, showcasing JHipster's functionalities and the community involved in its development.

1. Being productive with
JHipster
Julien Dubois & Deepu K Sasidharan
1

2. Who we are
● Julien Dubois
○ JHipster creator & lead developer
○ Chief Innovation Officer at Ippon Technologies
● Deepu K Sasidharan
○ JHipster co-lead
○ Product developer at XebiaLabs
2

3. React to the talk!
● Mention @java_hipster
● We’ll do our best to answer you during the talk!
3J

4. Introduction to JHipster
● Spring Boot + AngularJS application generator
● Fully Open Source
● +250 contributors
● +5300 Github stars
● +320,000 installations
● +100 companies officially using it
4D

5. Server side frameworks
5J

6. Client side frameworks
6D

7. Section I Installation & Application
Generation
7

8. Installation
● Installation with NPM
● Alternative installations: Docker, JHipster Devbox
> npm install -g generator-jhipster@3.9.1
8D

9. oh-my-zsh
● oh-my-zsh is a framework for managing your ZSH configuration
○ http://ohmyz.sh/
● Specific JHipster plugin
○ Also recommended: git, docker and docker-compose plugins
> jh
9J

10. Creating an application
● Questions & answers to generate an application tailored to your needs
● Questions depend on the previous answers
● Validation & help to avoid mistakes
> mkdir myapp && cd myapp
> yo jhipster
10D

11. IDE configuration
● Intellij IDEA, Eclipse, Netbeans
○ Specific “IDE” profile for MapStruct
● Visual Studio Code
○ Usage with Maven/Gradle or JHipster App
> idea .
11J

12. What has been generated?
● Spring Boot application
● AngularJS application
● Liquibase changelog files
● Configuration files
12D

13. The generated screens: security
● Several generated screens
○ Login, logout, forgot password…
○ Account management
○ User management
● Useful for most applications
○ Pages must be tuned depending on business needs
○ User roles will be added/extended
● Provide also good examples of working screens
○ Forms, directives, validation...
13J

14. The generated screens: administration
● Administration screens
○ Monitoring
○ Health
○ Spring Boot configuration
○ Spring Security audits
○ Log management
● Very useful in production
● Will probably be a separate module in JHipster 4
14D

15. Maven / Gradle usage
● Maven/Gradle wrappers
● Available goals: clean, compile, run, test...
● Specific profiles: “dev” and “prod”
> ./mvnw clean test
15J

16. Docker and Docker Compose
● JHipster generates full Docker & Docker Compose configuration
○ Build an image for the current application
○ Launch services: MySQL, Elasticsearch, Kafka...
○ Sonar
● Very useful in development, and for microservices
> docker-compose -f src/main/docker/mysql.yml up -d
16D

17. SQL Database support
● Can use different development & production databases
● H2 disk-based and in-memory
● Supported databases: MySQL, MariaDB, PostgreSQL, Oracle
● Spring Data JPA
● HikariCP
17J

18. Liquibase
● Liquibase manages database updates
○ Using changelogs
● Great for working in team
○ After a “git pull”, your database is always up-to-date!
● Tables, relationships, data are all created by JHipster at generation time,
and applied when the application starts
18D

19. Hibernate 2nd level cache
● 3 options
○ No cache
○ Ehcache
■ Default for monoliths
■ Upgrade soon to Ehcache 3
○ Hazelcast
■ Default for microservices, with a specific configuration for clustering
● Automatically monitored
○ Production defaults are low, should be tuned depending on your business/hardware
19D

20. MongoDB
● Alternative to SQL databases
● Faster startup, works great for cloud applications
● Spring Data MongoDB
● Changelogs are managed by Mongobee
20J

21. Cassandra
● Another alternative to SQL databases
● Custom implementation using the DataStax Java Driver
● Custom changelog implementation
● Spring Boot Cassandra support comes from JHipster!
21J

22. Elasticsearch
● Optional add-on to the other options
○ Very popular
● Use Spring Data Elasticsearch
● Add server-side and client-side code for searching entities
● Uses by default an embedded server in development, we recommend the
Docker image for faster turnaround
22D

23. Kafka
● Optional add-on
○ For handling very large amount of events
○ Some people use it to handle load and failover with microservices
● Use Spring Cloud Stream
● Simple integration for the moment
23J

24. Security
● Session-based authentication
○ Stateful
○ Classical “form-based” authentication with Spring Security
○ Improved remember-me over the standard Spring Security implementation
● OAuth2
○ Stateless
○ Needs a specific back-end, only works with SQL and MongoDB
● JWT
○ Stateless
○ Very good for microservices
24D

25. Internationalization
● i18n is managed by Angular Translate on the client-side
● “normal” Java i18n is used on the server-side
● 26 langages out-of-the-box, easy to extend
25J

26. Swagger
● Automatic documentation for all REST APIs
● Executable and easy-to-use
● Great for AngularJS developers (no need to read the Spring MVC REST
code!)
26D

27. WebSockets
● Optional add-on
● Uses Spring WebSockets
○ Easy to integrate
○ Hard to scale on several nodes
● Sample generated screen to track users live
○ Tracks who is logged in, their current screen, all in real time
27J

28. Creating an entity
● The entity sub-generator is our more complete and more popular
sub-generator
● Creates an entity, with full CRUD support
○ Liquibase changelog
○ Spring Data JPA repository
○ Spring MVC REST endpoint
○ AngularJS router/controller/service/view
○ i18n
○ Tests
● Tip: use Git to save your work before/after running a sub-generator!
28D

29. Creating fields
● Fields are created one after the other
● Lots of types are available
○ Types depend on the underlying database (SQL/MongoDB/Cassandra)
● Validation is available
○ AngularJS validation on the client side
○ Bean validation used by Spring MVC REST and Hibernate
○ Database constraints
29J

30. Managing relationships
● Relationships only work for SQL databases
● All JPA relationship types are supported
○ one-to-one, many-to-one, one-to-many, many-to-many
● Unidirectional and bidirectional relationships
● Multiple relationships on the same 2 entities
30D

31. The “User” entity
● Specific entity, generated with the core application
○ Used by Spring Security
○ Can be extended
● Supports many-to-one, many-to-many (non owner side) and one-to-one
(non owner side) relationships
● Tip: some people do a one-to-one relationship to a specific “CustomUser”
entity, which they modify/extend (modifying the User entity can cause
issues when upgrading the application)
31J

32. Using DTOs
● DTOs = Data Transfer Objects
● Very useful in business applications, where basic CRUD entities are not
enough
○ Add business logic
○ Separate the view layer from the persistence layer
○ Helps with lazy-loading
● Uses MapStruct to generate the mapping
○ Java annotation processor
32D

33. Using a service layer
● Very useful in business applications, where basic CRUD entities are not
enough
○ Like DTOs
○ Usually both options are selected at the same time, but it depends on what you want to do
● Service beans are Spring beans: security, transactions, monitoring are
available
● Option to use just an implementation, or an interface + an implementation
33J

34. Pagination options
● 3 pagination options are available:
○ Simple pager
○ Pagination links
○ Infinite scroll
● Depends on your business needs and database capabilities (Cassandra
can’t do pagination links)
● Very useful if you have data (all situations except reference tables)
○ Common pitfall is to do Gatling tests on non-paginated entities
34D

35. Re-generating an entity
● The entity sub-generator can re-generate an existing entity
○ Just call it again with the entity name
○ Fields and relationships can be removed/added
● Tip: advanced users modify directly the .jhipster/*.json files
○ Internal JHipster configuration files
○ In fact just the answers serialized in JSON - easy to understand and modify if needed
35J

36. Upgrading an application
● Upgrades can be done automatically with the Upgrade sub-generator
● Use Git branches to generate the application with a different version
● Automatic merge if there is no problem
● Conflicts must be resolved manually
> npm install -g generator-jhipster@3.10.0
> yo jhipster:upgrade
36D

37. Section II Working with the Generated
Application
37

38. Setting up a good development environment
● “Developer Experience” is very important for JHipster
○ Lots of effort to make your development environment great
● Hot reload should work everywhere
● IDEs should work automatically
● Docker Compose for all 3rd-party tools, so they are easy to manage
38J

39. Spring Boot devtools
● Automatically reloads the application when a compilation occurs
○ The application classloader gets refreshed
○ The JVM and third-party libraries are not refreshed
● Hot reload is very quick: 2 to 4 seconds depending on your setup
● Liquibase being managed by JHipster, the database schema is also
automatically updated
● Tip: configure your IDE to do automatic compilation, and everything is
updated automatically!
39D

40. Spring Data JPA
● Easily generate SQL requests from Java method names
○ List<Product> findByOrderByName()
○ List<Item> findByUser(User user)
○ List<Customer> findByLastName(String lastName)
● Tip: type the method name in the REST controller that uses it, and then use
your IDE to automatically generate the method
40J

41. Fluent methods in JPA entities
● JPA entities generated by JHipster have fluent methods
● Allows to chain method calls on entities
Post post = new Post()
.title("Fluent methods are cool!")
.createdOn(LocalDate.now())
.addPostComment(postComment);
41J

42. Liquibase
● Changelogs are generated by JHipster, and can also be hand-coded
● Another solution is to use the Maven “liquibase:diff” goal
○ Modify the JPA code
○ Compile the application
○ Run “./mvnw liquibase:diff”
○ This will generate a changelog to update your database schema
○ Add the resulting changelog to the master changelog
● Changelogs are applied at application start-up (also works with Spring
Boot hot reload)
42D

43. Gulp & BrowserSync
● Gulp allows to run many JavaScript tasks: minification, injection, tests…
● One of its main usage with JHipster is to run BrowserSync
● BrowserSync has 2 great features
○ Synchronizes clicks, scrolls and inputs on different browsers: great for testing with several
screen resolutions!
○ Reloads the browser(s) when a file changes: great for doing web application development!
● Tip: combined with Spring Boot devtools and Liquibase, a correct JHipster
development environment should have everything hot reloaded
automatically!
43J

44. Bower
● Installation and update of JavaScript/CSS libraries for the client-side
application
● If BrowserSync runs in the background, libraries are automatically injected
in the index.html page (otherwise, do a “gulp inject” to force the injection)
● Tip: in JHipster 4.0, Bower should disappear, and will be totally replaced by
NPM
> bower install bootstrap-material-design#0.3.0 --save
44D

45. Profiles
● JHipster manages profiles both at runtime (Spring profiles) and at build
time (Maven/Gradle profiles)
● 2 main profiles
○ “dev” for development: focuses on great Developer Experience
○ “prod” for production: focuses on the best performance for production
● Other profiles are for specific situations
○ “swagger” Spring profile to enable/disable Swagger
○ “no-liquibase” Spring profile to disable liquibase
○ “ide” Maven profile to help configuring the IDE (for MapStruct usage)
45J

46. Working with AngularJS
● JHipster follows the John Papa style guide
○ Official guide, endorsed by the AngularJS team
○ Lots of rules and best practices, clearly explained
○ Gives a migration path to AngularJS 2
● JHipster uses a few third-party libraries
○ UI Router for routing
○ Twitter Bootstrap
○ Datepicker, infinite scrolling
● All other libraries are supposed to be installed easily through Bower
46D

47. A word on Angular 2
● Angular 2 support is coming soon in JHipster!
○ Work is 90% ready on the main generator
○ The entity sub-generator is not migrated yet
○ We will have a new option to generate either an AngularJS 1 or an Angular 2 project
○ Both options will live next to each other
○ Focus will shift to Angular 2 as more projects adopt it, and as it becomes more stable
● This will be the main focus of JHipster 4.0
47D

48. Customizing Bootstrap
● JHipster uses the “standard” Twitter Bootstrap classes
● They can be overridden as usual
○ Update the main.css file if using CSS
○ Update the main.scss if using Sass
● It’s also easy to install a specific theme (often automatic just using Bower)
● Bootstrap 4 support is coming in JHipster 4.0
48J

49. Section III Testing the Generated Application
49

50. Spring integration tests
● JHipster provides JUnit and Spring integration test support
○ Integration tests are fast as the Spring context and the database are re-used over each
test
○ Mockito is used to mock dependencies
○ @WithMockUser from Spring Security is great
○ Yes, using field injection with Spring is annoying for tests!
● The entity sub-generator generates specific tests for each CRUD operation
50J

51. Karma.js
● Unit tests are generated for the main application and for the entities
○ Uses mock to simulate the back-end
51D

52. Gatling
● Available as an option
● Generate load testing simulations for CRUD entities
○ Uses the 4 CRUD methods
○ Must be tuned depending on your real business needs
○ Generates a great dashboard
○ Don’t forget to use pagination!
● Gatling tests can be run directly from Maven
● Simulations are developed with a Scala DSL
○ Not very complex to use
○ Scala compilation is slow at startup!
52J

53. Cucumber
● Available as an option
● Behavior-driven tests becoming more and more popular
● Simple integration at the moment
○ Might not evolve as we can’t generate business code
53D

54. Protractor
● Great way to do integration testing with AngularJS
○ End-to-end test of the application
○ Needs a fully working back-end server
○ Uses by default a Firefox browser, which often leads to issues
54J

55. Code quality with Sonar
● Sonar gives a complete quality report of the application
○ Java and Spring code
○ JavaScript code
● JHipster provides a Docker Compose configuration with a fully working
Sonar server
> docker-compose -f src/main/docker/sonar.yml up -d
> ./mvnw clean test sonar:sonar
55J

56. Continuous integration
● Travis configuration is generated
○ Full test of both the back-end and the front-end
○ Similar to what the JHipster team uses to test the generator itself!
● Jenkins 2 configuration is generated
○ With complete documentation on the JHipster website for Jenkins 1 and 2
56D

57. Section IV Going to Production
57

58. JHipster production build
● Generates an executable WAR file with production options
○ Minified front-end
○ GZip filter
○ HTTP cache headers
> ./mvnw clean package -Pprod
> docker-compose -f src/main/docker/mysql.yml up -d
> cd target
> ./myapplication-0.0.1-SNAPSHOT.war
58J

59. Monitoring JHipster
● Standard Spring Boot Actuator endpoints are available
○ With a UI!
● Dropwizard Metrics is configured
○ JVM & HTTP request metrics
○ Spring Beans metrics
○ Ehcache metrics
● Logs can be sent to an ELK server
○ More about the JHipster Console in the “microservices” section
59D

60. Building a Docker image
● Full Docker configuration has been generated in the src/main/docker
folder
○ A Dockerfile
○ A Docker Compose configuration with the application and its dependencies
● The Docker daemon must be running when the Docker image is built
> ./mvnw package -Pprod docker:build
> docker-compose -f src/main/docker/app.yml up
60J

61. The Docker Compose sub-generator
● Works for both monoliths and microservices
● Allows for more complex setups than the default Docker Compose file
○ Adding monitoring with the JHipster Console
○ Mostly useful for microservices
61J

62. Docker Compose & Docker Swarm
● Docker Compose applications can be deployed to Docker Swarm cluster
○ Having a production-grade Docker Swarm cluster is very hard
○ Deploying to a cluster is similar as deploying locally
● Applications launched in a cluster can be scaled
○ Works out-of-the-box for microservices
○ A gateway/load balancer is necessary to handle port conflicts
○ Hibernate 2nd level cache must be disabled, or distributed
> docker-compose -f src/main/docker/app.yml scale myapplication-app=3
62D

63. Deploying on Kubernetes
● Kubernetes sub-generator is in BETA
○ Developed by Ray Tsang (@saturnism) from Google
○ Similar to the Docker Swarm sub-generator
> yo jhipster:kubernetes
63J

64. Deploying to Cloud Foundry
● Specific sub-generator to deploy to Cloud Foundry
● Uses the “cf” command-line to deploy the application, bind a database
service, etc.
○ Can only support services available on your Cloud Foundry marketplace
> yo jhipster:cloudfoundry
64D

65. Deploying to Heroku
● Specific sub-generator to deploy to Heroku
○ Developed by Joe Kutner from Heroku
● Uses the “heroku” command-line to deploy the application, bind a database
service, etc.
> yo jhipster:heroku
65J

66. Other deployment platforms
● AWS
● BoxFuse
● Application servers
● Executable WAR
66D

67. Section V Tooling & sub-projects
67

68. JDL
● JHipster Domain Language
● Makes generating complex entity models easily
● Supports all entity sub-generator features
○ Field types
○ Validation
○ Relationships
○ DTOs
○ Service
○ Enumerations
○ ...
68J

69. JDL Studio
● Open Source Web application
○ Available at http://jhipster.github.io/jdl-studio/
● Auto-completion and validation
● Sublime Text keymap
● Graphical view
● Share as URL
● Import/export models
69D

70. JHipster IDE
● IDE support for JDL
○ Eclipse, IDEA, Visual Studio Code
○ Still in Beta
70J

71. Modules
● JHipster modules gives all the power of JHipster sub-generator to
everyone
○ Modules are independent from JHipster
○ Modules are Yeoman generators, using the JHipster public API
○ Release when you want, use the license you want…
● If you want your module to be public, you can publish it on the JHipster
marketplace
○ Available at https://jhipster.github.io/modules/marketplace/
○ 24 modules available today
○ Free for everyone, as always with JHipster!
71D

72. Section VI Microservices
72

73. Microservices architecture
● JHipster provides a full microservice architecture
● Gateway(s) to give access to the microservice architecture
○ Based on Netflix Zuul
● Registry to find services
○ JHipster Registry (based on Netflix Eureka) or Hashicorp Consul
● Microservices
● Security
● Monitoring
● Scaling
73J

74. Microservices architecture
74J

75. Gateway(s)
● Gateways are normal JHipster applications
○ Full JHipster capabilities
● Provide access to the microservices
○ Using Netflix Zuul for routing, load balancing, failover
○ Provide security using JWT or OAuth2
○ Provide quality of service using a custom Zuul filter + Cassandra
○ Provide full Swagger documentation for both the gateway and the microservices
● Tip: you can have several gateways, specialized on your business needs
75D

76. Microservices
● Microservices are normal JHipster applications, without the AngularJS
front-end
● All database combinations, Elasticsearch and other options are available
● The JDL Studio can also be used to generate the CRUD entities
● Main limit is that Websockets are not available
○ Will change with Zuul 2
76J

77. JHipster Registry
● JHipster Registry is an Open Source application developed specifically for
the JHipster microservices architecture
○ Uses Netflix Eureka for service registration/discovery
○ Uses Spring Cloud Config to push Spring Boot configuration to microservices
■ Very useful for pushing secrets (like database passwords)
■ Can re-configure microservices
■ Configurations can be stored in Git, allowing to version/tag them easily
○ Has an easy-to-use Web interface (built with JHipster!)
○ Is available pre-built as a Docker image on the Docker Hub
77D

78. HashiCorp Consul
● Alternative to the JHipster Registry
○ Focus on consistency (while Eureka focuses on availability)
● More efficient than Eureka on many points
○ Faster service registration/un-registration
○ Smaller footprint
○ DNS server included
○ UI included
● But the JHipster Registry is more stable, is easier to extend (it’s a JHipster
application) and has better Spring Cloud Config support
78J

79. JHipster Console
● Monitoring application built with ELK (Elasticsearch Logstash Kibana)
● Optimized for JHipster
○ Receives directly events from JHipster over a socket, with the correct format
○ Has pre-configured dashboards for JHipster
● Can be automatically set up with the Docker Compose sub-generator
● Available pre-built as a Docker image on the Docker Hub
79D

80. Customizing Netflix Zuul
● Gateways use Netflix Zuul to provide routing, load balancing and failover
● Netflix Zuul can be customized using filters
○ JHipster provides pre-built filters, for example for quality of service
● New filters can be added depending on your business needs
80J

81. Generating entities with microservices
● Entities can be generated for microservices, like any JHipster application
○ Only the back-end code is generated (no AngularJS client code is generated)
○ All usual options are available
○ The JDL Studio can be used as usual
● For Gateway(s), entities can also be generated from microservices
○ The front-end is generated on the gateway, and connect through Netflix Zuul to the
microservice back-end
○ Front-end applications can gather entities from several microservices, as well as from
entities from the gateway itself
81D

82. Hazelcast distributed cache for
microservices
● Hazelcast is the default Hibernate 2nd level cache for entities generated
on microservices
● JHipster generates specific configuration, using the JHipster Registry, so
that different instances of the same microservice join each other in the
same distributed cache
● Distributed cache with Hazelcast will work automatically with Docker
Swarm, when a microservice is scaled
> docker-compose scale mymicroservice-app=3
82J

83. Security for microservices
● Default security is JWT
○ The JWT token is generated by the gateway
○ All microservices accept the token, as they share a secret key with the gateway
○ This secret key is sent to all gateway(s) and microservices by the JHipster Registry, using
Spring Cloud Config
● Beta option to support OAuth2
○ Using the JHipster UAA server
83D

84. Deploying and scaling on Docker Swarm
● Same as deploying on a local Docker, but on a full cluster!
● Main difference is that we can scale microservices
○ This is why distributed cache and JWT are important
> docker-compose up -d
> docker-compose scale mymicroservice-app=3
84J

85. Deploying and scaling on Kubernetes
● Basically the same as Docker Swarm, but on Kubernetes
○ Works on Google Cloud Platform
○ Still in Beta
> kubectl apply -f myapplication
> kubectl scale --replicas=3 jhipster/myapplication
85D

86. Section VII Getting help
86

87. Community help
● #1 rule: everything is public
● Questions are on StackOverflow with the “jhipster” tag
● Bugs & feature requests are on our GitHub issue tracker
● Please follow our contributing guidelines if you want help!
87J

88. Questions?
Answers!
88