Building multi tenancy enterprise applications

Micro-services
Architecture
Domain-Driven-Design
Multi-tenancy
DevOps
Building Multi-tenancy Enterprise Applications
with DDD Approach
Jinyoung Jang
OpenCloudEngine.org
(jyjang@uengine.org)

Enterprise SaaS Application
최근 Economist Intelligence 에 의한 국제
적 조사 (293개 기업 CIO, 조사국가: 미
국 39%, 영국 31%, 호주 30%)에 의하면
5개 기업중 4개는 자신의 고객들이 제화
와 서비스를 제공받는 방식에 어떤 변화
를 원하고 있다고 답했다. 그리고 실제로
반이 넘는 기업들은 가격모델과 제공방
식을 변경하였거나 계획 중이라고 답했
다. 그러한 변화 중 가장 많은 40% 로 대
답한 것은 바로 ‘ 구독형 서비 스
(Subscription Service)’의 도입으로 조사
됐다.

성공적 서비스로의 여정
운영자동화
• Business Continuity
• Zero-downtime
수익화
• Subscription Business
구현
• Mashups
• Multi-tenancy
• Self-Serviced
마이크로 서비스
• Separation of Concerns
Successful Ser
vice

성공적 서비스로의 여정
운영자동화
• Business Continuity
• Zero-downtime
수익화
• Subscription Business
구현
• Mashups
• Multi-tenancy
• Self-Serviced
마이크로 서비스
• Separation of Concerns

Share more, More cheap offering, More C
ompetitive in the market !
Share less, More easy & Secure !
Creating Innovative Application
Multi-tenancy Support

가입자A의 앱설정 가입자B의 앱설정
* 멀티태넌시 지원 기능은 금번 사업 범위에 비포함
* 향후 현재 R&D문서관리 등은 멀티태넌트 전환이 필요함
2. 도입기관별 입력 항목 변경
3. 도입기관별 판정로직 설정
1. 도입기관 브랜드 설정
Metadata-based

Self Service

Tenant-aware! Inject tenant-specific logics, workflows, brand
Tenant-specific
Store
SPOSAD Architecture

Tenant-specific Customization > Custom Database Schema > S
hared Database vs. Shared schema
© 2013 uEngineCloud, I
nc.
Rigid, shared table Extension tabl
es
Datatype-specifi
c pivot tables
Private tables
Universal tabl
e with XML d
ocument
Universal table
Supporting Multi-tenancy
어떤 DB 구조로 설계해야 하나요?

Force.com: Multi-tenant Kernel

NoSQL databases
1. Inherent multi-tenancy - Schema Free
2. High Performance - Horizontally scalable and Memory cache
3. Web optimized – Query results are JSON - data can be
parsed by web browser directly and performantly.
Additionally -
4. Easy to implement Analytic services (MR) and Full Text Search
5. Event-driven Transaction - don't have to care about CQRS
something
6. Some NoSQL products (Couchbase, Cassandra) provides
pessimistic locking and ANSI SQL (Join Query) - easily
migrate to them.

Libraries and tools for Multi-tenancy
support
• Multi-tenancy Database Frameworks
– JPA @Discriminator annotation (Hibernate,
EclipseLink)
– Athena Framework
– Spring Cloud
– Corent-technology’s JDBC/ODBC proxy
• Metadata framework (SPOSAD)
– IBM J9 JVM - @TenantScope annotation
– Athena Framework
– Adaptive Object Model
– OCE multi-tenancy metadata framework

DevOps: Issues
Continuous Delivery
18
Company Deploy Frequency Deploy Lead Time Reliability Customer
Responsiveness
Amazon 23,000 / day Minutes High High
Google 5,500 / day Minutes High High
Netflix 500 / day Minutes High High
Facebook 1 / day Hours High High
Twitter 3 / week Hours High High
Typical enterprise Once every 9 months Months or quarters Low / Medium Low / Medium
출처: 도서 The Phoenix Project
Amazon,

Twitter는얼마나자주 배포할까요?

19
2. 배포 주기
• 매일 마이너 업데이트
• 메이저 업데이트 (매주 화요일 오후)
3. Deployment

Pipeline
출처: http://ieeexplore.ieee.org /xpl/artic leDet ails.jsp?arnumber=6449236
Supporting Continuous Delivery
Facebook

20
4. Canary를통해서확신 갖기
• Canary란? 실제production

subset에서새로운코드를 돌려보고 옛날
코드와 비교해서 새로운 코드가어떻게 돌아가는 지 보는 것
• Canary

avg등이옛날 코
드랑 새로운 코드랑 비교해서 어떻게다른 지 확인하는것)은 1000개 이상의metric을
비교해서 100점 만점에 점수를 주고 일정 점수일 경우만배포할 수 있음.
출처: http://techblog.netf lix.com/2013/08/dep loying -netf lix -ap i.ht ml
Supporting Continuous Delivery
Netflix

CPU
MEM Disk
WAS
Storage
Service
(e.g. S3)
Memory
Service
(e.g. Redis)
Micro
Service
Architecture
Existing Enterprise
ApplicationHAarchitecture
wire network
Managing“SPOF (SinglePoint Of Failure)”
DevOps
Managing Single Point of
Failure

Managing SPOF
Micro Services Architecture

출처 : 2010 architecting for the cloud (http://www.slideshare.net/simone.brunozzi/2010-architecting-for-the-cloud-4719195)
DevOps: Issues
Managing Scalability

Managing Scalability
Workload Distribution Engine

• IBM Bluemix
• Heroku
• GE’s Predix
• Pivotal Web
Services
• Cloud Foundry
Container
Workload
Distribution Engine
(OSS)
PaaS
• Warden(Garden)
• Docker • Kubernetes
• Docker SWARM
• Mesos Marathon
• Google Compute
Engine
• Redhat Open Shift
• Hypervisor • CF version 1
• Engineyard….
• Amazon Beanstalk
DevOps
DevOps Platforms

DevOps Platform
IBM Bluemix – Auto Scaling

DevOps Platform
IBM Bluemix – Zero Downtime
Deploy

Monolithic Architecture
à 모든 서비스가 한번에 재배포
à 한팀의 반영을 위하여 모든 팀이 대기
à 지속적 딜리버리가 어려워

Micro Service Architecture
Contract based, Polyglot Programming
à Separation of Concerns, Parallel Development, Easy Outsourcing
Written in Java
Written in Node
Written in PHP

• 변경된 서비스만 재배포
à Side effect 최소화
• 자율성
à 각 서비스에 대한 자유로운 언어, 아키텍처, 아웃소싱 용이
• 병렬 개발, 타임 투 마켓, 린 개발

Building multi tenancy enterprise applications

API Gateway
(Human)
Front-end
Servi
ce
Service
API G/W
Service
Service
We need API Gateway for aggregating, forwarding
services and exposing composite APIs
Tenant-Specific Routing
(Machine)
Third-party Apps

Billing
(Human)
Front-end
Service
Service
API G/W
Service
Service
We need API Gateway for aggregating, forwarding
services and exposing composite APIs
Tenant-Specific Billing
(Machine)
Third-party Apps
Billing

Metering / Loggregator
(Human)
Front-end
Service
Service
API G/W
Service
Service
로그를 수집하여, 테넌트별 사용량을 집계한 후 빌링에게 전달
(Machine)
Third-party Apps
Billing
Metering
(Loggregator)

IAM
(Human)
Front-end
Service
Service
API G/W
Service
Service
Stateless 인증, 통합빌링을 위한 IAM
Tenant Billing
(Machine)
Third-party Apps
Billing
IAM token
provider

Design factors on developing cloud
applications
1. Don't code your application directly to a specific topology
2. Do not assume the local file system is permanent
3. Don't keep session state in your application
4. Don't log to the file system
5. Don't assume any specific infrastructure dependency
6. Don't use infrastructure APIs from within your application
7. Don't use obscure protocols
8. Don't rely on OS-specific features
9. Don't manually install your application
38

Design Factor for Front-end
One Page
N-Screen
Responsive
Dynamic
Real-time

Front-end
Image
Server
(Python)
Business
Logic
Server
(Java)
Extended Role of Front-end in Cloud Applications
Aggregator for multiple (polyglot programmed) micro-services
Component
Service
(C)
AJAX, RESTful
Concurrent Cloud Applications are composed of multiple
Micro Services and front-end serves as an aggregator of the
services

Writing One Page Web App
Problems: One Page Web App à Low Cohesion and High Coupling
style
style for A
style for B
style for C
/style
html
element for A
element for B
element for C
/html
script
script for A
script for B
script for C
/script

Polymer: Web Component Framework
Polymer: W3C standard for Web Components
• Provides Cohesive Component Model
• Component Composition by HTML
markup
• Dynamic Data Binding
• Responsive Web by Material Design
• Standard
• Google maintains it

Polymer: Web Component Framework
Polymer: W3C standard for Web Components
style
style for A
style for B
style for C
/style
html
element for A
element for B
element for C
/html
script
script for A
script for B
script for C
/script
#A.html
style
style for A
/style
html
element for A
/html
script
script for A
/script
#B.html
style
style for B
/style
html
element for B
/html
script
script for B
/script
#C.html
style
style for C
/style
html
element for C
/html
script
script for C
/script
#index.html
A A
B B B
C

• UI Framework for MSA
– AngalarJS
– React
– Polymer
– VueJS
• API Gateway
– APIGee (Commercial)
– Kong
– OCE Gateway
– Amazon Cognito (Public)
– Spring Cloud
• IAM
– Amazon IAM (Public)
– Spring Cloud
– OCE IAM
• Metering / Billing
– Exem’s Metering Framework – BigData based
– OCE Billing
Platforms for MSA

Platform for MSA
OCE API Gateway

Example: Proposed SaaS Ar
chitecture
프론트엔드 (Responsive,
Client-‐
side
Service
Aggregate)
확장가능한 글로벌
싱글 인스턴스 데이
터베이스
(NoSQL
-‐
Couchbase)
서비스
API
G/W
서비스
서비스
Scalable,
Client-‐driven,
Microservices
architecture
Tenant
Billin
g
(Machine)
써드파티 앱
들
Billing
IAM
token
provi
der
local
DB
(pouchDB)
CRUD
1.data
sync
2.REST

Leaders Mainstream Laggards
Pricing strategy • Pricing metrics are defined as p
erceived by the customers
• Pricing strategy is easy to under
stand, measure.
• Boundaries for usage,
features, time, conversion
from trial are clearly define
d
• Pricing is ad hoc
• Pricing is based on internal
ly-oriented metrics
• Difficult to convert trial an
d freemium to paid
• Leader 들은 고객 관점에서 가격을 책정, 시장상황에 빠르게 가격 및 정책
개선
• 후발기업들은 내부 비용에 초점, 변경하지 않음

Zuora Aria
Hiveage Chargify
And more..
Monetization
Platforms For Monetization

Monetization Platform
Zuora - Billing Metering As A
Service

Monetization Platform
OCE Billing – Open Source Billing Metering

• 구독형 (공유자원 확장성)
• 다종단말
• 마이크로 서비스
• 스마트 프론트-엔드
Mission: 향후 10년 사용할 아
키텍처
• 설치형
• 단일단말
• 모놀리씩
• 무거운 백엔드

Reference SaaS App
https://github.com/TheOpenCloudEngine/micro-service-architecture
특징
• 멀티테넌시
• 셀프서비스 (객체관리)
• 클라이언트 기반 서비스
통합
• 로컬 캐시 DB (오프라인
에서도 동작, 서버 접속
시 동기화)
• 토큰 인증 (IAM)
• API GW 통한 CRUD DB
접근

Reference SaaS App
github.com/TheOpenCloudEngine/micro-service-architecture
Front-‐end
(VueJS)
CouchDB
OCE
API
G/W
Tenant
Billing
OCE
BillingOCE
IAM
local
DB
(pouchDB)
CRUD
1.data
sync
2.REST
OCE
Metadata
Service
Self-‐service
Portal
Generate UIs

References
• www.opence.org
• https://www.ibm.com/developerworks/websphere/techjournal/14
04_brown/1404_brown.html
• http://microservices.io
• [Google Search] The SPOSAD Architectural Style for Multi-tenant
Software Applications
• https://github.com/TheOpenCloudEngine/polymer-java-mapping
• https://github.com/TheOpenCloudEngine/OCEIAM-
SERVICEWARRPER
• https://github.com/TheOpenCloudEngine/oceIAM

DDD / MSA based SaaS Application
Development Framework – metaworks4
60

Metaworks4
Open Source SaaS Platform mimicking Salesforce’s Multitenant Kernel
www.metaworks4.io

Concepts Backgrounds
도메인 주도 설계 마이크로 서비스 아키텍처 머터리얼 디자인

DDD(Domain-Driven Design) - 도메인 주도 설계
• 마이크로서비스를 구현하기에 앞서 설계하기 위해 필요한 유용한 개념 DDD.
• 추천 도서 : “Eric Evans의 Domain Driven Design”, 도메인 주도 설계
• DDD에서 얻을 수 있는 해법(책에서 다루는 내용)
• 어떤 단위로 서비스를 구성할 것인가
• 서비스의 결합
• 변화에 강한 설계
• 레거시 시스템을 단계적 폐기
• 리팩터링 전략
• Domain Model 정제과정의 예
• http://agiledata.org/essays/agileDataModeling.html
63

Micro Services Architecture
• https://martinfowler.com/articles/microservices.html
64

MW4 개발 프로세스
생
성
생
성
• Full-fledged Responsive Web
Single Page Application
• With google-material design• POJO based Domain Model
• Add annotations (JAX-RS, JPA,
Jackson, metaworks)
• Domain Class Analysis
도메인
클래스
모델링
애노테이
션
UI 컴포넌
트 배치

Model
metadata
Front
(Vue.js /
polymer)
REST backend
(Spring hateoas)
ORM
(Spring
JPA)
Domain Class
Developer
generates generates
generates
How it works

Multi-tenant / Self service Support
Self service
Self service
portal
• Add new attribute
• Attributes can be String,
number, Data from referenced
class (table)
• Change the title, order of
attributes
• Hide/Show attribute

Model
metadata
Front
(Vue.js /
polymer)
REST backend
(Spring
hateoas)
ORM
(Spring
JPA)
Domain ClassSelf-Service Portal
couchbase
Tenant
Admin
Developer
overrides
Overriding
metadata
generates generates
generates
How it works

활용 오픈소스 – for building app
Vue.js Vue MaterialFront
REST Service
Persistence

활용 오픈소스 – 2 – for MSA
BackEnd 1
IAM
API GW
BackEnd 2
Billing/
Metering
Front
OCE-IAM
OCE-API-GW
OCE-Bill
www.opence.org

개발환경 구축
• Apache Maven 3.x
– Will import following dependencies automatically:
• Spring Framework
• Tomcat Runtime
• Mysql Java Library
• ORM-related Libraries including JPA
• Integrated Development Environment:
Intelli-J CE 12 or higher
• Database-related tools:
Mysql Server, Mysql workbench
(Mysql Java Library will be automatically imported by maven)
71

URL for sample project
72
https://github.com/TheOpenCloudEngine/micro-service-
architecture-vuejs

Building Sample Application
73
Backend server (Runs on 8080)
mvn spring-boot:run
Front-end server (Runs on 8081 or any other port)
cd src/main/resources/static
npm install npm run dev
Go to http://localhost:8081/login.html

Dependencies
74
- MySQL DB and Couchbase Installation
- Setting the connection info to the WebConfig.java:
https://github.com/TheOpenCloudEngine/micro-service-architecture-
vuejs/wiki

Running Sample App - login
75
Default login id / pw is
jyjang@uengine.org / test
Login will be processed through the IAM server:
http://iam.uengine.io:8080

Running Sample App – Product - Master
76
• Main Screen is in a material-
design fashion
• You may reduce the screen
size to see it is responsive to
the device

Running Sample App – Product – Insert
77

Running Sample App – Product – Delete
78

Running Sample App – Progress
79

Running Sample App – Progress –
Referencing Master Values
80

Running Sample App – Self Service
81
필드추가

Getting token from IAM directly
• curl -X POST http://iam.uengine.io:8080/oauth/access_token
-H 'cache-control: no-cache'
-H 'content-type: application/x-www-form-urlencoded'
-H 'postman-token: 8ecd37ed-0bc7-3e93-bae6-b5514fd010cd'
-d 'client_id=e74a9505-a811-407f-b4f6-
129b7af1c703grant_type=passwordclient_secret=109cf590-
ac67-4b8c-912a-
913373ada046username=sppark2password=gosu23546scope
=uEngineSubscriptions%2Fsubscriptionsapitoken_type=JWTclai
m=%7B%22aaa%22%3A%22bbb%22%7D'
83

Curl for main service
• curl localhost:8080 -H access_token:
eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0OTgwNTQ4NzUsImNvbnRleHQi
Onsic2NvcGVzIjoidUVuZ2luZVN1YnNjcmlwdGlvbnNcL3N1YnNjcmlw
dGlvbnNhcGkiLCJ1c2VySWQiOiJhYzUyYzczYTVlZTI0NjM2OThiMDc0
MDgwMGZkZTQ2MCIsImNsaWVudEtleSI6ImU3NGE5NTA1LWE4MT
EtNDA3Zi1iNGY2LTEyOWI3YWYxYzcwMyIsInVzZXJOYW1lIjoianlqY
W5nQHVlbmdpbmUub3JnIiwibWFuYWdlbWVudElkIjoiZGRmZWZlYz
A3ODliNGRiZmIwMGM3MjU2MTFiYjY5NWUiLCJyZWZyZXNoVG9rZ
W4iOiI0ODhlMmM2MC1mNWQyLTQ5M2EtYTk5YS0xN2QxMzZiZmI
zYzEiLCJ0eXBlIjoidXNlciIsImNsaWVudElkIjoiMmNlZTkwMjMxNjMyN
GNkNGJiMmQ5NjQ4NzM5MDFlZWIifSwiaXNzIjoib2NlLmlhbSIsImN
sYWltIjp7fSwiaWF0IjoxNDk4MDE4ODc1fQ.lPfzsnqv1bBdl9EcVRwY
RDtIVbVMDMdDUzeOpgfwfQs
84

• curl localhost:8080 -H access_token:
eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0OTgwNTQ4NzUsImNvbnRleHQiOnsic2NvcGVzIjoidUVuZ2luZVN1YnNjcmlwdGlvbnNcL3N1YnNjcmlw
dGlvbnNhcGkiLCJ1c2VySWQiOiJhYzUyYzczYTVlZTI0NjM2OThiMDc0MDgwMGZkZTQ2MCIsImNsaWVudEtleSI6ImU3NGE5NTA1LWE4MT
EtNDA3Zi1iNGY2LTEyOWI3YWYxYzcwMyIsInVzZXJOYW1lIjoianlqYW5nQHVlbmdpbmUub3JnIiwibWFuYWdlbWVudElkIjoiZGRmZWZlYz
A3ODliNGRiZmIwMGM3MjU2MTFiYjY5NWUiLCJyZWZyZXNoVG9rZW4iOiI0ODhlMmM2MC1mNWQyLTQ5M2EtYTk5YS0xN2QxMzZiZmIz
YzEiLCJ0eXBlIjoidXNlciIsImNsaWVudElkIjoiMmNlZTkwMjMxNjMyNGNkNGJiMmQ5NjQ4NzM5MDFlZWIifSwiaXNzIjoib2NlLmlhbSIsImNs
YWltIjp7fSwiaWF0IjoxNDk4MDE4ODc1fQ.lPfzsnqv1bBdl9EcVRwYRDtIVbVMDMdDUzeOpgfwfQs”
• {
• _links : {
• person : {
• href : http://localhost:8080/person{?page,size,sort},
• templated : true
• },
• progress : {
• href : http://localhost:8080/progress{?page,size,sort},
• },
• product : {
• href : http://localhost:8080/product{?page,size,sort},
• },
• profile : {
• href : http://localhost:8080/profile
• }
• }
• }
85

• curl localhost:8080 -H access_token: access token”
• {
• _links : {
• person : {
• href : http://localhost:8080/person{?page,size,sort},
• },
• progress : {
• href : http://localhost:8080/progress{?page,size,sort},
• },
• product : {
• href : http://localhost:8080/product{?page,size,sort},
• },
• profile : {
• href : http://localhost:8080/profile
• }
• }
• }
86

CORS Settings
87
@Configuration
@ComponentScan(basePackageClasses = {TenantAwareFilter.class, MetaworksRestService.class, ProductRepository.class,
ClassManager.class, MetadataService.class})
@EnableJpaRepositories(repositoryBaseClass = CustomGenericRepositoryImpl.class)
public class WebConfig extends WebMvcConfigurerAdapter {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping(/**)
.allowedOrigins(*)
.allowedMethods(POST, GET, PUT, DELETE, OPTIONS)
.allowedHeaders(access_token, Content-Type);
}

The Size of Code
89
323Lines
For Developing Full-CRUD, RESTful, MSA-based,
Material-Designed, Responsive, Grid+Form, Multi-
tenant and Self-Served Application:
• Number of fields of the entity: 10
• Total lines of code per an entity:
92 for front-end,
215 for domain class,
16 lines for repository.

Anatomy of SaaS Platform:
Doman Driven Design and Metadata Oriented
Framework
90

Implementing Multi-tenant Polymorphism
91

Adaptive Object Model
92
http://adaptiveobjectmodel.com
• Class Definition model in
instance level
• Definition can be stored in a
XML file or database.
• Very Flexible to Extend
• Polymorphism for multi-
tenant
Drawbacks:
• Hard to read code
• Error-prone

Reflection + AOM
93
• Since Java 1.2
• Java Class definition can be
accessible with Reflection
APIs
• For the concrete part, Get
the Metadata from Class
Definition
• For the flexible part, use the
AOM

Annotation + Reflection + AOM
94
• Since Java 1.5
• Rather use separated XML
files, use @ for specifying
additional (user-defined)
metadata for class definition

Metaworks
1. Metadata Oriented Application Framework
2. Developed by Jinyoung Jang in 1998
3. Inspired from the Adaptive Object Models, OMG Reflection, and MDA
4. Application Component Generation on the fly from metadata
5. Metaworks1: Generates database query and action, Simple Web Forms
generation. written in ASP - 1998
6. Metaworks2: Generates Swing User interfaces written in Java, is adopted in
uEngine Process Designer – 2003
7. Metaworks3: Generates Dynamic Web Uis. Metadata definition by annotation,
is adopted in Process Codi SNS, Web based BPMN Modeler and the Cloud
IDE of OCE garuda – 2011
8. Metaworks4: Inherits concept of Metaworks 1 ~ 3. Get off from the inherent
MVV VueJS for front-end, Spring Hateoas and JPA for back-end.

Metaworks
So Metaworks3…
1. Is A POJO framework
2. Encourages the Domain-Driven Design
3. Especially for developing model-driven applications

Metaworks for early prototyping
• Metaworks generates Dynamic Web Applications on the fly from
your domain class model with minimal technical details.
• By reading the metadata declared by class model itself and the
additional annotations.
• Metaworks doesn’t generate any source codes so doesn’t requires
any round-trip job for source codes while MDA need such a job.
Metadata
Domain Model
Classes
User Interaction
Validation
Database Manipulation
Dynamic Web UIs
Swing Native UIs
Mobile Native UIs*

Metaworks for Multi-tenancy
Common Metadata
Domain Model
Classes
Class model for tenant1
ORM for tenant1
Common class model
Metadata of
Tenant1
Metadata of
Tenant2
Metadata of
Tenant3
ORM for tenant2
ORM for tenant3
Override by tenantID

Development Process
1. (Optional) UML을 이용한 설계
2. 도메인 자바 코드의 생성
3. 타 POJO Framework의 적용 - JPA를 통한 ORM 생성, JAX-RS를 통한 서비
스 공개
4. Metaworks3 Framework의 적용을 통한 Default Application 의 생성
5. UI 구체화 / 커스터마이징
6. 1~5 반복

Why JPA?
• The (almost-final) Java Standard
• Why not iBatis or hibernate ?
– JPA is a POJO Framework while the others not.
– Also Hibernate engine supports JPA as a interface.
• Why POJO framework is goooooood?
– To focus on the domain-driven design
– To yield the sophisticated Java class system to solve your Doman-
Specific problem.
– A POJO frameworks would not limits your domain models, they only
gives an ‘advice’ through @Annotation or Aspect-oriented manner.
– So, you can introduce one or more frameworks without changing the
domain classes.
100

Basic JPA annotations
• @Entity identifies this class is a ORM Class.
• @Id means this field is a primary key.
• @JoinColumn means a foreign value referenced by a foreign key.
• @OneToMany means this field is an accessor of related entity in
‘One-to-many’ relationship.
101

Key Generation Strategy
102
• Native/AUTO:
• SEQUENCE:

Data Insertion Test
103
public static void main(String[] args) throws PersistentException {
PersistentTransaction t = autoinsurance.AutoinsurancePersistentManager.instance().getSession().beginTransaction();
try{
Customer customer = new Customer();
customer.setCustomer_ID(“1”);
customer.setCustomer_first_name(“Jane Doe”);
customer.setVehicle(new ArrayList());
customer.getVehicle().add(new Vehicle());
autoinsurance.AutoinsurancePersistentManager.instance().getSession().save(customer);
t.commit();
}
catch (Exception e) {
t.rollback();
throw e;
}

Creating UIs
• Developing UI Applications is very complex and costly:
– Native UI: Swing
– Web UI: JSP, Struts
– N-Screen UI: AJAX / html5 / CSS
• Development Lifecycle is getting shorter and shorter:
– Lean Startup
– Early Prototyping
• So, we need something agile development approach such as:
– Model-Driven Development
– Application Frameworks
– SOA and Process Orchestration Architecture
104

History of OO Frameworks and
Methodologies
1. Smalltalk
2. STL (Standard Template Language) of C++
3. Adaptive Object Models – Ralf Johnson
4. Design Patterns – Gang of four
5. Object-Oriented Frameworks
6. OMG Reflection
7. Java – 1995
8. IBM’s San francisco Framework
9. Java 2 Enterprise Edition – EJB 2.1
10.EJB Patterns
• Bigger and Complex Super Classes
• Java doesn’t Support Multiple Inheritance

Domain Specific Application Frameworks
Example of Business Domain Specific Application Frameworks :
1. Car Simulation
2. Product Simulation
3. Or your Problem itself!!
à abstracts business problems
Example of System Domain Specific Application Frameworks :
1. EJB
2. Struts
3. Swing
4. Apache Mesos
à abstracts technical problems
But We Can’t Inherit Two Super Classes at the same
time!!!
Merging two
or more
frameworks??

Return to the “Pure Java”
- Aspect Oriented
Programming
- Java Annotation
- JPA
- JAX-RS
- EJB 3.1

EJB 2.1 vs EJB 3.1
출처: http://www-
01.ibm.com/support/knowledgecenter/SS8PJ7_9.1.0/com.ibm.javaee.doc/topics/

Domain-Driven Design
1. Using ‘Ubiquitous Language’ so that the domain expert and developer
can communicate

Spring Data + Hateoas Framework
110

Microservices with Spring Boot + Spring Data
Using Spring Boot and Spring Data
to quick develop HATEOAS microse
rvices
Bernardo Silva

Terminology
• What is CRUD?
• What is REST?
• What is Spring?
• What is HATEOAS?
• What is Microservice?
• So… hands on!

What is CRUD?
• “In computer programming, create, read, update and delete (as a
n acronym CRUD or possibly a Backronym) (Sometimes called SC
RUD with an S for Search) are the four basic functions of persist
ent storage.”
Ø http://en.wikipedia.org/wiki/Create,_read,_update_and_delete

What is REST?
• “Representational state transfer (REST) is an abstraction of the ar
chitecture of the World Wide Web; more precisely, REST is an arch
itectural style consisting of a coordinated set of architectural const
raints applied to components, connectors, and data elements, wit
hin a distributed hypermedia system.”
• http://en.wikipedia.org/wiki/REST

Basic CRUD with REST
Operation HTTP / REST
Create PUT / POST
Read (Retrieve) GET
Update (Modify) PUT / PATCH
Delete (Destroy) DELETE

What is Spring?
• “The Spring Framework is an open source application framework a
nd inversion of control container for the Java platform.”
Ø http://en.wikipedia.org/wiki/Spring_Framework
§ Inversion of control container / dependency injection
§ Enrichment and proxying

Inversion of control container / dependenc
y injection:
class A {
B b = new Bimpl();
}
interface B {
(…)
}
class Bimpl implements B {
(…)
}
@Component
class A {
@Autowired
B b;
}
interface B {
(…)
}
@Component
(…)
}
Spring

Enrichment and proxying:
@Component
class A {
@Autowired
B b;
}
interface B {
(…)
}
@Component
(…)
}
Spring
ProxyImplements
Delegates

Using AOP for Metering / Billing – 1
@Metered(project.start)
public void executeProcess(String instanceId) throws Exception{
ProcessInstance instance = getInstance(instanceId);
instance.execute();
}

Using AOP for Metering / Billing – 2
@Aspect
public class MeteringAdvice {
@Before(@annotation(metered))
public void checkAvailable(Metered metered) throws
NoServiceAvailableException {
…..
//Check if the service is available for the requested
tenant
}
@AfterReturning(@annotation(metered))
public void meter(Metered metered) throws Exception {
….
//Add usage log
}
}

Essencia – Build Deploy Automation
Essencia On-Premise
Essencia On Amazon
Essencia On Bluemix
Overrides:
1. applicationContex.xml (to use AmazonS3Storage)
2. Uengine.properties (to change DB connection info)
Overrides:
1. applicationContex.xml (to use services)
2. pom.xml (Cf push command)

What is HATEOAS?
• “HATEOAS, an abbreviation for Hypermedia as the Engine of Appli
cation State, is a constraint of the REST application architecture th
at distinguishes it from most other network application architectur
es.”
Ø http://en.wikipedia.org/wiki/HATEOAS

HATEOAS samples
person xmlns:atom=http://www.w3.org/2005/Atom
firstnameDave/firstname
lastnameMatthews/lastname
links
atom:link rel=self href=http://myhost/people/1 /
/links
/person
XML
{ firstname : Dave,
lastname : Matthews,
links : [ { rel : self, href : http://myhost/people/1 } ] }
JSON

What is Microservice?
• “The term Microservice Architecture has sprung up over the last
few years to describe a particular way of designing software applic
ations as suites of independently deployable services.”
Ø http://martinfowler.com/articles/microservices.html

Microservices Reference
• The “ID” on a HATEOAS system is mainly an URI
– Example: If you create a “teacher”, his “id” will be “http://localhost:80
80/teacher/1” instead of just “1”.
• Then, each Microservice can reference other services entities.

So… hands on!
1) Using Gradle, you create a simple Spring Boot
project:
Ø http://projects.spring.io/spring-boot/
2) You create a basic Spring Boot main class (it c
an be converted to a WAR later).
3) Then you boot doing:
Ø gradle bootRun

build.gradle
• Buildscript dependencies:
Ø classpath(org.springframework.boot:spring-boot-gradle-plugin:1.1.5
.RELEASE”)
• Body:
Ø apply plugin: 'spring-boot’
• Dependencies:
Ø compile(org.springframework.boot:spring-boot-
starter-web”)

Application.java
• Annotations:
Ø @Configuration
Ø @ComponentScan
Ø @EnableAutoConfiguration
§ Main method (unnecessary for WAR):
Ø SpringApplication.run(Application.class, args);
Magic!

Adding Hibernate (ORM)
• build.gradle (dependencies):
Ø compile(org.springframework.boot:spring-boot-st
arter-data-jpa”)
Ø compile(com.h2database:h2:1.3.176)
Ø compile(org.projectlombok:lombok:1.14.4)
Just to make
Entities more
dumb

Adding Spring Data REST
• build.gradle (dependencies):
Ø compile(org.springframework.data:spring-data-r
est-webmvc)
• Application.java:
Ø @Import(RepositoryRestMvcConfiguration.class)
SUPER
Magic!

Teacher and Student DDL
TEACHER
ID
NAME
SUBJECT
STUDENT
ID
NAME
AGE
STUDENT_TEACHERS
STUDENT_ID
TEACHER_ID

Adding “Teacher” entity
@Data
@Entity
@EqualsAndHashCode(exclude={students})
public class Teacher {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String subject;
@ManyToMany
@JoinTable(name = STUDENT_TEACHERS,
joinColumns = { @JoinColumn(name = TEACHER_ID)},
inverseJoinColumns = { @JoinColumn(name = STUDENT_ID)})
private SetStudent students;
}

Adding “Student” entity
@Data
@Entity
@EqualsAndHashCode(exclude={teachers})
public class Student {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private Integer age;
@ManyToMany
@JoinTable(name = STUDENT_TEACHERS,
joinColumns = { @JoinColumn(name = STUDENT_ID)},
inverseJoinColumns = { @JoinColumn(name = TEACHER_ID)})
private SetTeacher teachers;
}

Adding REST repositories
@RepositoryRestResource(
collectionResourceRel = student, path = student)
public interface StudentRepository extends
PagingAndSortingRepositoryStudent, Long {
}
@RepositoryRestResource(
collectionResourceRel = teacher, path = teacher)
public interface TeacherRepository extends
PagingAndSortingRepositoryTeacher, Long {
}
TeacherRepository.java
StudentRepository.java

Run and be amazed!
• Try to get the root service description:
Ø GET: http://localhost:8080/
• Try to create two students, two teachers and associate them!
Ø POST: http://localhost:8080/student
• Use “PATCH” with “text/uri-list” to link entities
• Get JSON Schema of the entity:
Ø GET: http://localhost:8080/student/schema
Ø Accept: application/schema+json

Examples:
• POST: http://localhost:8080/student
Ø { name: John, age: 18 }
Ø { name: Jorge, age: 19 }
• POST: http://localhost:8080/teacher
Ø { name: James, subject: Math }
Ø { name: Bob, subject: Biology }
• PUT/PATCH: http://localhost:8080/student/1/teachers
Ø Content-Type: text/uri-list
http://localhost:8080/teacher/1
http://localhost:8080/teacher/2
• GET: http://localhost:8080/teacher/1/students

Vue JS + VueMaterial
137

W3C Web Components
Custom elements
HTML imports
Template
Shadow DOM

So
Why AngularJS、React、Vue.js、Ember、Pol
ymer、Riot...etc
Polyfill

Why vue.js
Angular and React is not STANDARD
Polymer is heavy and needs Polyfill
Vue.js is
1. Fastest (compared with React and Angular)
2. Light (low dependencies)
3. Usable with jQuery or existing .js libraries,

Features of Vue.js
• Reactive data binding (Spreadsheet-like)
• Composable view components (Tag-based)

Hello World!
http://vuejs.org.cn/#example

Data binding
div id=demo
p{{message}}/p
input v-model=message
/div
a v-bind:href=url/a

v-model
spanMessage is: {{ message }}/span
br
input type=text v-model=message placeholder=edit me

v-if：conditional element
v-else
h1 v-if=okYes/h1
h1 v-elseNo/h1

v-for
ul id=example-1
li v-for=item in items
{{ item.message }}
/li
/ul
var example1 = new Vue({
el: '#example-1',
data: {
items: [
{ message: 'Foo' },
{ message: 'Bar' }
]
}
})

v-on
div id=example
button v-on:click=greetGreet/button
/div
var vm = new Vue({
el: '#example',
data: {
name: 'Vue.js'
},
// 在 `methods` 对象中定义方法
methods: {
greet: function (event) {
// 方法内 `this` 指向 vm
alert('Hello ' + this.name + '!')
// `event` 是原生 DOM 事件
alert(event.target.tagName)
}
}
})
// 也可以在 JavaScript 代码中调用方法
vm.greet() // - 'Hello Vue.js!'

• init
• created
• beforeCompile
• compiled
• ready
• attached
• detached
• beforeDestroy
• destroyed
Life cycle

User defined Component
(Your own HTML Tag)
Vue.component('child', {
// public attributes, properties
props: ['msg'],
template: 'span{{ msg }}/span’
data: function(){// private attributes, properties
return {a:’aaa’, b:’bbb’}
},
// behaviors
methods:{
}
})
child msg=hello!/child

One File Component - .vue
template
div class=hello
h1{{ msg }}/h1
/div
/template
script
module.exports = {
data: function () {
return {
msg: 'Hello World!'
}
}
}
/script
style scoped
h1 {
color: #42b983;
}
/style

Metaworks4 components
object-form

reference-picker

object-grid

iam-login

iam-menu

self-service-portal

self-service-mashup

Development Process:
Analysis Modeling Domain Classes with
UML Tool (DDD Approach)
160

IntelliJ and VP integration
161
1. In Visual Paradigm, select Windows
Integration IDE Integration... from
the toolbar. (for some version, Tools
IDE Integration)
2. Select IntelliJ IDEA. You can run Visual
Paradigm in multiple IDEs. In other
words, if you need you can select
multiple IDEs here. Click Next.
3. Specify the folder path of IntelliJ IDEA.
Click Next to start copying files to
your IDE.
(Currently VP supports only IntelliJ 12 or
under)

IntelliJ and VP integration
162

Using Visual Paradigm In IntellJ
2. Opening a VP in
IntellJ
163
3. Import existing
model
1. Open the created
maven project

Importing Existing Model
164
• File Visual Paradigm EE Import UML Model
• Choose the existing .vpp file

Entity-Relationship Diagram
165

Generate ERD and Entity Classes (ORM)
• Open the Class Diagram in the
Project Explorer Diagram Navigator
ClassDiagram
• Set the type of attributes
– String for most types
– boolean for gender
– int for options
– double for money
– java.util.Date for Dates, timestamp
• Modeling ORM Generate Code
• Database Code Generation Options:
– Framework: JPA
– Persistence API: POJO
• Be careful:
– All attributes must have its type
– All classes should be belong to any
package
166

Create a Class Diagram and Generate Java
Code in IntelliJ-VP integration
168

Navigating between Model and Code
Jumping from diagram to Code:
Right-click on the class Select in
Code
169
Jumping from Code to Diagram:
Right-click on the source file
Visual Paradigm EE Select in
Diagram

Automatic Code Synchronization
• Modeling Enable Auto Synchronization
170

EXERCISE : CREATING ORM AND
DATABASE CONNECTION
171

Create a new class diagram
172

All classes must be ORMPersistable
174

All relations must be Persistable
175

Then, they can be converted to ERD
176

If there is no ID field (primary key), VP will
generate them automatically
178

Generated Sample CRUD Code
183

Generated Entity Classes (JPA)
• All Entity Codes are POJO Classes that are described with Java Annotations meaning
entity field descriptions and relationships.
185
@Entity
@Table(name=Customer)
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name=Discriminator, discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue(Customer)
public class Customer implements Serializable {
public Customer() {}
@Column(name=ID, nullable=false)
@Id
@GeneratedValue(generator=AUTOINSURANCE_CUSTOMER_CUSTOMER_ID_GENERATOR)
@org.hibernate.annotations.GenericGenerator(name=AUTOINSURANCE_CUSTOMER_CUSTOMER_ID_GENERATOR, strategy=native)
private String customer_ID;
@Column(name=Customer_social_security_number, nullable=true, length=255)
private String customer_social_security_number;
@Column(name=Customer_first_name, nullable=true, length=255)
private String customer_first_name;
@Column(name=Customer_middle_initial, nullable=true, length=255)
private String customer_middle_initial;
@Column(name=Customer_last_name, nullable=true, length=255)
private String customer_last_name;
@OneToMany(mappedBy=owns, targetEntity=autoinsurance.Vehicle.class)
@org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.LOCK})
@org.hibernate.annotations.LazyCollection(org.hibernate.annotations.LazyCollectionOption.TRUE)
private java.util.Set vehicles = new java.util.HashSet();
}

Day-2: Make the Application As A Service
186

Introduction to REST
REST stands for Representational State Transfer
• It is an architectural pattern for developing w
eb services as opposed to a specification.
• REST web services communicate over the HT
TP specification, using HTTP vocabulary:
– Methods (GET, POST, etc.)
– HTTP URI syntax (paths, parameters, etc.)
– Media types (xml, json, html, plain text, etc)
– HTTP Response codes.

HTTP-REST Vocabulary
HTTP Methods supported by REST:
• GET – Requests a resource at the request URL
– Should not contain a request body, as it will be discarded.
– May be cached locally or on the server.
– May produce a resource, but should not modify on it.
• POST – Submits information to the service for processing
– Should typically return the new or modified resource.
• PUT – Add a new resource at the request URL
• DELETE – Removes the resource at the request URL
• OPTIONS – Indicates which methods are supported
• HEAD – Returns meta information about the request URL

HTTP-REST Vocabulary
A typical HTTP REST URL:
• The protocol identifies the transport scheme that will be used t
o process and respond to the request.
• The host name identifies the server address of the resource.
• The path and query string can be used to identify and customi
ze the accessed resource.
http://my.store.com/fruits/list?category=fruitlimit=20
protocol host name path to a resource query string

JAX-RS Basics
An example REST service class:
• At least one method must be annotated with an HTTP verb (e.g. @GET)
• The @Controller annotation makes the class discoverable by Spring
package org.lds.tech.training.lab.ws;
import javax.ws.rs.GET;
import org.springframework.stereotype.Controller;
@Controller
public class HelloWebServiceRest {
@GET
public String sayHello() {
return Hello, World!;
}
}

JAX-RS Basics
Example Spring configuration:
• Example location: WEB-INF/example-servlet.xml
• A reference to the JAX-RS annotated service bean is pass
ed to the Stack RS “produce” namespace handler.
• Multiple service beans may be supplied under the Stack R
S “interfaces” element.
• Each bean will be scanned by CXF for annotated resource
s that can be served up RESTfully.
stack-rs:produce
stack-rs:interfaces
ref bean=helloWebServiceRest/
/stack-rs:interfaces
/stack-rs:produce

JAX-RS Basics
An example WADL descriptor:
application xmlns=http://wadl.dev.java.net/2009/02
xmlns:xs=http://www.w3.org/2001/XMLSchema
resources
base=http://localhost:8080/example/Services/rest
resource path=/
method name=GET
response
representation mediaType=application/octet-stream
param name=result style=plain type=xs:string/
/representation
/response
/method
/resource
/resources
/application

JAX-RS Method Annotations
JAX-RS HTTP Method Annotations:
@GET @POST
@PUT @DELETE
@OPTIONS @HEAD
• Applied to a Java method to bind it to an HTTP meth
od.
• Only one HTTP annotation may be applied to a singl
e Java method.
• Multiple Java methods may be given the same HTTP
method annotation, assuming they are bound to diff
erent paths.

JAX-RS @Path Annotation
• @Path annotations may be supplied to customize the reques
t URI of resource.
• @Path on a class defines the base relative path for all resou
rces supplied by that class.
• @Path on a Java class method defines the relative path for t
he resource bound to that method.
• @Path on a method is relative to any @Path on the class.
• In the absence of @Path on the class or method, the resour
ce is defined to reside at the root of the service.
• A leading forward slash (/) is unecessary as the path is alwa
ys relative.

JAX-RS Annotations: Examples
@Path(example)
public class ExampleWebServiceRest {
@GET
public Item getItem(@QueryParam(itemId) Long id) {
// @QueryParam example
}
@POST
public Response editItem(@FormParam(itemId) Long id,
@FormParam(value) String value) {
// @FormParam example
}
@GET
@Path({category}/{subcategory:[^/]*})
public ListItem getItems(
@PathParam(category) String category) {
@PathParam(subcategory) String subcategory) {
// @Path and @PathParam example
}
}

JAX-RS Annotations
Examples of @Produces and @Consumes:
• The client submits JSON or XML content with the “C
ontent-Type” header.
• The client requests either JSON or XML content thro
ugh use of the HTTP “Accept” request header.
@Path(example)
public class ExampleRestService {
@POST
@Path(items)
@Produces({application/json, application/xml})
@Consumes({application/json, application/xml})
public ListItem editItems(ListItem items) {
// Does something and returns the modified list
}
}

Operations behind the scene
• JSON(XML) serialization / deserialization
• Networking between Requester and Provider
• Dynamic method invocation
197

Service Orchestration with BPM
• uEngine BPMS is an open source software supporting BPMN 2.0
• Pools for service definition
• Using data mapper, detailed message inter-change between pools
can be done
198

Export BPMN xml file from VP
• Exporting BPMN 2.0 xml
• File Visual Paradigm Export BPMN 2.0
199

Importing BPMN xml to Activiti BPM
• Activiti BPM is an another open source BPMS supporting BPMN 2.0
• Processes Model workspace Import
• Select the BPMN xml file
200

Service Oriented Architecture Applied
201

Overview
204
Requirement of Cloud
Service Deployment
Cloud Deployment
using IaaS
Cloud Deployment
using PaaS

Design factors on developing cloud
applications
1. Don't code your application directly to a specific topology
2. Do not assume the local file system is permanent
3. Don't keep session state in your application
4. Don't log to the file system
5. Don't assume any specific infrastructure dependency
6. Don't use infrastructure APIs from within your application
7. Don't use obscure protocols
8. Don't rely on OS-specific features
9. Don't manually install your application
205

Your
Future
Apps
PaaS
“Instance-on” Middleware and Platform Services
A PaaS provides development services on cloud.
CLOUD IDE

PaaS가 해주길 기대하는 것들
* 출처: IBM

PaaS의 유형들
• Application PaaS: OSS서비스에 집중
e.g. 클라우드 파운드리, 오픈시프트
• Business PaaS: BSS on OSS (OSS+BSS)
e.g. 포스닷컴, IBM SmartCloud, GAE, OCE
• Monetization PaaS: BSS + 소비자분석
e.g. Zuora, Aria Systems

Building multi tenancy enterprise applications

More Related Content

What's hot (20)

Similar to Building multi tenancy enterprise applications (20)

More from uEngine Solutions (20)

Recently uploaded (20)

Building multi tenancy enterprise applications