{"id":93990,"date":"2019-07-08T11:38:18","date_gmt":"2019-07-08T08:38:18","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=93990"},"modified":"2019-07-15T09:34:52","modified_gmt":"2019-07-15T06:34:52","slug":"java-microservices-spring-cloud-config-jhipster","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2019\/07\/java-microservices-spring-cloud-config-jhipster.html","title":{"rendered":"Java Microservices with Spring Cloud Config and JHipster"},"content":{"rendered":"

Friends don\u2019t let friends write user auth. Tired of managing your own users?<\/b> Try Okta\u2019s API and Java SDKs today. Authenticate, manage, and secure users in any application within minutes.<\/a><\/span><\/p>\n

Developing a microservice architecture with Java and Spring Boot is quite popular these days. It\u2019s definitely one of the most popular combinations in the Java ecosystem. If you need any proof, just look at all of the similar frameworks that have cropped up in the last few years: MicroProfile, Micronaut, and Quarkus, just to name a few.<\/p>\n

Spring Boot provided a much-needed spark to the Spring ecosystem when it was first released in 2014. Instead of making Java developers configure all aspects of their Spring beans, it provided “starters” that contained pre-configured beans with the default settings. This led to less Java code, and also provided the ability to override the defaults via an application.properties<\/code> file. Yes, there are many ways to modify the defaults in a Spring Boot application, but I\u2019ll skip over that for now.<\/p>\n

In a\u00a0previous tutorial on Java Microservices with Spring Boot and Spring Cloud<\/a>, I showed how you can use OAuth 2.0 and OpenID Connect to secure everything. One of the problems with this example is that you have to configure the OIDC properties in each application. This can be a real pain if you have hundreds of microservices. Yes, you could define them as environment variables and this would solve the problem. However, if you have different microservices stacks using different OIDC client IDs, this approach will be difficult.<\/p>\n

Java Microservices with Spring Cloud Config<\/h2>\n

Spring Cloud Config<\/a> is a project that provides externalized configuration for distributed systems. Spring Cloud Config has server and client components. You can configure the server to read its configuration from the file system or a source code repository, like Git. On the client, you configure things in a bootstrap configuration file to get configuration data from the server. In a microservices environment, this provides an elegant way to configure all<\/em> your microservices from a central location.<\/p>\n

Today I\u2019d like to show you how this works and demo it using one of the hippest microservice solutions I\u2019ve ever worked with.<\/p>\n

Use JHipster to Generate a Java Microservices Architecture<\/h2>\n

JHipster<\/a> is a development platform to generate, develop, and deploy Spring Boot + { Angular or React or Vue } applications. In addition, it supports creating Spring-based microservice architectures. In fact, if you create microservices projects and choose OAuth 2.0 \/ OIDC for authentication, you\u2019ll be using code that\u2019s very similar to the aforementioned example.<\/p>\n

To use JHipster, you\u2019ll need to have Node.js<\/a> installed. You can also use start.jhipster.tech<\/a>, which is similar to start.spring.io.<\/p>\n

The most common way to install JHipster is using npm:<\/p>\n

npm install -g generator-jhipster@6.0.1<\/pre>\n
\n
 You can run the command above without the version number to get the latest version of JHipster. If it\u2019s 6.x, this tutorial should<\/em> work, but I can\u2019t guarantee it does. <\/p>\n<\/blockquote>\n
In a terminal, create a directory to hold all the projects you\u2019re about to create. For example, jhipster<\/code>.<\/p>\n
Create an apps.jh<\/code> file in this directory and put the following code into it.<\/p>\n
application {\n  config {\n    baseName gateway,\n    packageName com.okta.developer.gateway,\n    applicationType gateway,\n    authenticationType oauth2,\n    prodDatabaseType postgresql,\n    serviceDiscoveryType eureka,\n    testFrameworks [protractor]\n  }\n  entities Blog, Post, Tag, Product\n}\n\napplication {\n  config {\n    baseName blog,\n    packageName com.okta.developer.blog,\n    applicationType microservice,\n    authenticationType oauth2,\n    prodDatabaseType postgresql,\n    serverPort 8081,\n    serviceDiscoveryType eureka\n  }\n  entities Blog, Post, Tag\n}\n\napplication {\n  config {\n    baseName store,\n    packageName com.okta.developer.store,\n    applicationType microservice,\n    authenticationType oauth2,\n    databaseType mongodb,\n    devDatabaseType mongodb,\n    prodDatabaseType mongodb,\n    enableHibernateCache false,\n    serverPort 8082,\n    serviceDiscoveryType eureka\n  }\n  entities Product\n}\n\nentity Blog {\n  name String required minlength(3),\n  handle String required minlength(2)\n}\n\nentity Post {\n  title String required,\n  content TextBlob required,\n  date Instant required\n}\n\nentity Tag {\n  name String required minlength(2)\n}\n\nentity Product {\n  title String required,\n  price BigDecimal required min(0),\n  image ImageBlob\n}\n\nrelationship ManyToOne {\n  Blog{user(login)} to User,\n  Post{blog(name)} to Blog\n}\n\nrelationship ManyToMany {\n  Post{tag(name)} to Tag{post}\n}\n\npaginate Post, Tag with infinite-scroll\npaginate Product with pagination\n\nmicroservice Product with store\nmicroservice Blog, Post, Tag with blog\n\n\/\/ will be created under 'docker-compose' folder\ndeployment {\n  deploymentType docker-compose\n  appsFolders [gateway, blog, store]\n  dockerRepositoryName \"jmicro\"\n  consoleOptions [zipkin]\n}\n<\/pre>\n
\n
 You\u2019ll want to change the dockerRepositoryName<\/code> in the JDL above to use your Docker Hub<\/a> username if you want to publish your containers. This is not a necessary step to complete this tutorial. <\/p>\n<\/blockquote>\n
This code is JDL (JHipster Domain Language) and you can use it to define your app, its entities, and even deployment settings. You can learn more about JDL in JHipster\u2019s JDL documentation<\/a>. Below is a screenshot of JDL Studio, which can be used to edit JDL and see how entities related to each other.<\/p>\n
\n
\"Java<\/figure>\n<\/div>\n
The JDL you just put in apps.jh<\/code> defines three applications:<\/p>\n
    \n
  • gateway<\/strong>: a single entry point to your microservices, that will include the UI components.<\/li>\n
  • blog<\/strong>: a blog service that talks to PostgreSQL.<\/li>\n
  • store<\/strong>: a store service that uses MongoDB.<\/li>\n<\/ul>\n
    Run the following command to create these projects in your jhipster<\/code> folder.<\/p>\n
    jhipster import-jdl apps.jh<\/pre>\n
    This will create all three projects in parallel. You can watch the console recording below to see how it looks. The time it takes to create everything will depend on how fast your computer and internet are.