3DEXPERIENCE Services Customization — Interview Prep Guide

byAdmin -
0

Based on: Services Customization Guidelines, 3DEXPERIENCE R2022x (Dassault Systèmes) Target roles: Services Software Consultant / Services Software Architect

1. Platform Introduction

Core services/apps: 3DPassport (identity/auth), 3DSpace (data storage & sharing), 3DDashboard (dashboards/widgets), 3DSearch, 3DComment, 3DNotification, 3DSWYM (social collaboration), Enterprise & Control Centers (admin), DSLS (licensing).

Deployment architecture:

  • On-Premises: Presentation (web server/load balancer) → Logic & Access (app servers, e.g. 3DSpace, 3DPassport) → Data (database, index servers, NAS/SAN). Concepts: modularity, fail-over, load balancing.
  • On-Cloud: DS Control Center manages SaaS / PaaS / IaaS layers hosted on a DS Cloud Provider's data center.

Baseline vs. Customer-Specific Environment (CSE) — a favorite interview contrast:

Baseline CSE
Scope On-Prem + Cloud On-Prem only
Collaborative Spaces Flat (Public/Protected/Private) Hierarchical
Roles Horizontal (predefined) Vertical (tied to Host Company)
Upgrade support Supported by DS R&D MQL/Spinner customizations NOT guaranteed by DS

Key rule: once you pick Baseline or CSE, don't switch — objects are incompatible between the two. Default recommendation is to stay Baseline unless CSE is absolutely necessary.

MVC Architecture:

  • Model = Java Beans / schema (Attributes, Types, Relationships) in the database
  • View = JSP pages (HTML/JS + server code)
  • Controller = Servlets (handle HTTP requests, call business logic, dispatch to View)
  • Client → Request (HTTP) → Servlet → Java objects (Model) → JSP (View) → Response

Customization tools overview (be ready to name which is "recommended" vs "legacy" vs "not recommended"):

  • Recommended by DS: Data Model Customization app, Widgets, Collaborative Spaces Control Center, Business Rule Editor
  • Legacy (discouraged): 3DSpace UI Components, custom JSP pages/Legacy customization
  • Spinner: automation tool for admin/business objects (Triggers, Auto Number Generators) — not part of OOTB, requires separate license, not recommended by DS for CSE customization due to upgrade risk

Software Development & Customization Lifecycle (5 stages) — know this cold, it's the backbone of the whole course:

  1. Defining and Designing a Solution
  2. Building a Development Environment
  3. Developing a Solution
  4. Testing and Debugging
  5. Build and Release

2. Defining and Designing a Solution

Customization must be documented across: Data Model, UI Changes, Business Logic, Interfaces, P&O.

UML diagram types and when to use them:

Diagram Purpose
Deployment Runtime components & dependencies
Class Data model / mapping
Object Instanced view of a structure (e.g. BOM)
Sequence Complex data flows (e.g. web service interactions)
State Lifecycles (e.g. Policy lifecycle)
Use Case Requirements (out of scope of this course)

Best practice: avoid "wallpaper diagrams" — organize into packages (Data Model / Business Logic / Deployment) with sub-packages per App.

Four levels of customization (OOTB Quotation) — classic interview question:

  1. OOTB — works as-is or via simple config
  2. Parameterization — config change only, no code (e.g., new field/column)
  3. Adaptation — some code needed on top of existing functionality
  4. Development — functionality doesn't exist, built from scratch

Philosophy: always prefer OOTB/Baseline first; customize only as last resort.

Three customization approaches:

  • Top-Down (UI-driven): start from UI/forms → interactions → business logic → data model
  • Bottom-Up (Data-Model-driven): start from data model → object behavior → UI
  • Hybrid: both simultaneously — most thorough but slowest/least agile

3. Building a Development Environment

  • Eclipse IDE: standard for 3DSpace customization (Java EE Developers package). Alternatives: NetBeans, IntelliJ, VS Code.

    • Memory config in eclipse.ini: -vmargs -Xms512m -Xmx2048m
    • One Eclipse workspace per customer project

  • Code quality tools: SonarLint (current standard, replaced SonarQube's Eclipse plugin) vs. PMD (legacy, no longer used — SonarLint preferred).

  • Key 3DEXPERIENCE-specific Java code rules (good to recall a few by name):

    • Avoid wildcard (*) in relationship/vault queries — performance hit
    • Avoid DB calls inside loops
    • Use DomainObject over BusinessObject where possible
    • Avoid hardcoded Person context (privilege escalation risk)
    • Avoid JPO.invoke() inside another JPO (extra RMI calls)
    • Always wrap JPO code in try-catch; print stack trace, then rethrow
    • Use symbolic names, not hardcoded schema element names
    • Turn triggers back ON after turning OFF; Push/Pop context used together only

  • Project types in Eclipse: Simple Java Project (PoC/testing), Dynamic Web Project (JSPs/web apps), Build-tool projects (Maven/Gradle — dependency management, sharing), Multi-Project Environment (complex, independent sub-projects).

  • Misc dev tools: Mylyn (task/ALM integration with JIRA/Redmine/Mantis), Firefox Web Developer + DevTools, Postman (REST client), CSVed (editing Spinner files), Visual Studio Code.

4. Developing a Solution (largest lesson — expect the most questions here)

Data Model

  • Data Model = object types + relationships + attributes.
  • IRPC (Instance Reference Port Connection): core model for Native Apps (CATIA etc.). 6 core types: PLMCoreReference, PLMCoreInstance, PLMCoreRepReference, PLMCoreRepInstance, PLMPort, PLMConnection. 3 relations: Aggregation, Is Instance Of, Points To. (Derived types you'll see in practice: VPMReference, VPMInstance, 3DShape, VPMRepInstance.)
  • ER (Entity Relationship) Model: core model for Web Apps (3DSpace). Three main objects: Types (entities + attributes), Relationships, Interfaces/Extensions (add attributes under conditions). Policy is mandatory and defines: revision sequence, lifecycle, access control, signatures.
  • Tools: Data Model Customization app (Baseline + CSE), Collaborative Spaces Control Center, Spinner.
  • Governance: "Set Deprecated" to retire objects without deleting; can't extend an object with an Extension sharing an attribute name with another Extension already applied.

P&O (People & Organization) — now called "Organization Modeling & Secure Data Accesses"

  • 5 core concepts: Person, Collaborative Space, Organization, Roles, Security Context.
  • Security Context = Organization + Role + Collaborative Space combination; drives initial data ownership on object creation.
  • Setup tools: Web Console (Members Control Center — recommended for user creation/role/credential assignment) or Batch Tools (VPLMPosImport/VPLMPosExport, PassportUserImport). MQL is discouraged for Role/Company/Security Context/User creation.
  • Gotchas: must restart app server after batch user import (Pub/Sub); must register new users in 3DPassport via PassportUserImport or they can't log in; run OnPremisesSynchroUser.bat after P&O changes; CSE PnO customizations must be revalidated after every upgrade (not DS-guaranteed).

User Interface Customization

  • Widgets = lightweight HTML/JS apps, the modern (Dashboard-paradigm) replacement for legacy Classic Webtop pages. Multiple widgets combine into Dashboard "tabs."
  • Compass = entry point exposing 3 kinds of apps; Additional Apps can be added via REST web service automation (Postman workflow: CAS login ticket → CAS auth → CSRF token → create/edit additional app).
  • Legacy vs. Widget: prefer Widgets/Native App UI over legacy 3DSpace UI Components/custom JSP.

Business Logic Customization

  • JPO (Java Program Object) — main vehicle for custom server-side business logic; triggered via Triggers (ModifyDescription, ModifyAttribute, Promote, Connect, etc.).
  • Web Services: REST is the modern standard (stateless, JAX-RS annotations) vs. legacy SOAP/Doc-based (being phased out).
  • Security checklist for any Web API: Authentication (CAS/SSO), Access Control (role/right checks), Licensing checks, IP Protection, Encryption, CSRF token protection, Service Key for partner apps.
  • WAFData module: direct call (server serves data itself, cross-domain via shared servers) vs. proxified call (through a proxy — used for external/non-DS servers).
  • Login Tickets: for batch/unattended authentication scenarios only — not a general security mechanism.

Performance Practices (common interview scenario questions)

  • Rule 1: minimize DB calls — use getInfo() to batch-retrieve attributes instead of per-object calls.
  • Rule 2: never call DB inside a loop — X loop iterations × Y attributes = X×Y calls if done wrong; batch OIDs first, then one getInfo() call.
  • Use HashSet instead of StringList.contains() for membership checks (index vs. linear scan).
  • Be careful with where clauses in getRelatedObjects() — sometimes filtering the returned MapList in code is faster than the where-clause itself; also mind relationship direction and expand level.
  • UI tables: gather all OIDs first, then one batched getInfo() call for columns — not one query per row.

Logging Practices

  • Platform's native logging can't be finely configured (mixes trace types into one file).
  • SLF4J (Simple Logging Facade for Java) is the flexible alternative — an abstraction layer over Log4j/Logback/JUL. 3DEXPERIENCE's logging infrastructure uses SLF4J + Logback as the default.
  • Standard levels include ERROR (something wrong, must investigate) down through less severe levels — use parameterized logs, proper logger declarations, and log exceptions properly (not just swallow them).

5. Testing and Debugging

  • Testing types: Black-Box (no internal knowledge), White-Box (internal logic/code), Grey-Box (hybrid).
  • Test categories: Functional, Integration (~UI testing), Monkey (random edge cases), Performance/Capacity, Smoke (basic sanity), Unit.
  • TDD / Red-Green-Refactor cycle: write failing test → make it pass → refactor.
  • JUnit: annotations (@Test, @Before, @After, @BeforeClass, @AfterClass, @Ignore), assertions (assertEquals, assertTrue, assertNull, assertSame, etc.). Bad practices: tests that don't actually test the feature, multiple assertions per test, machine-dependent tests, tests that swallow exceptions.
  • CAA testing: mkodt is DS R&D's official Native App unit-test tool; Catch-2 also usable.
  • Widget debugging: browser dev tools / JS console, console.log().
  • UI Testing: Manual (Steps Recorder) vs. Automated (Selenium WebDriver). Best practice: layered architecture — Test Cases → Page Class → Abstraction Layer → Selenium; identify elements by ID, not text or fragile XPath.

6. Build and Release

  • Software factory components: Version Control, Build & Release Management, Software Configuration Management (SCM), Continuous Integration.
  • VCS: Git (distributed, preferred, strong branching) vs. SVN (centralized, legacy alternative).
  • Build tools: Maven (+ Nexus as artifact repository) is the recommended combo; alternatives are Ant+Ivy or Gradle.
  • SCM: tracks/controls source changes, ensures history, backups, single source of truth.
  • 3DSEI (3DS Environment Integration): DS's own tool (via WW E&C team) for schema/code merge across environments, using Spinner as a prerequisite; not part of OOTB, separately licensed, no DS support obligation.
  • CI: Jenkins is the de-facto standard (plugins, clean builds from source control, secure with LDAP, regular backups). GitLab CI/CD is the main alternative (built-in CI/CD, no third-party tools needed).

7. Documentation Practices

  • User's Guide (functional) vs Developer's Guide (CAA Encyclopedia, covers V5/V6 toolkits) — both at the platform's documentation portal.
  • Knowledge Base (support.3ds.com/knowledge-base) — searchable Q&A technical articles.
  • Customization docs live under help.3ds.com → Installation and Setup → 3DEXPERIENCE Platform → Configuration and Customization, organized by: P&O/Content, Platform Customization, 3DSpace Data Model, Security Management, Behavior, Store/Vaults, Deploying a Customization, Legacy Tools.

Quick Glossary (rapid recall)

  • 3DSpace: logical storage/secured sharing of content
  • 3DPassport: SSO identity/auth
  • 3DDashboard: unified widget-based view; Widget = smallest app unit; Tab = customizable page of widgets
  • 6WTags: user-defined tags attached to content
  • BPS: Business Process Services
  • P&O: People & Organization (access/security model)
  • CSE: Customer-Specific Environment
  • JPO: Java Program Object (custom server logic)
  • IRPC: Instance Reference Port Connection (Native App data model)
  • ER Model: Entity-Relationship (Web App data model)

Likely Interview Angles

  1. "Walk me through the customization lifecycle." → 5 stages, be ready to give a 1-liner per stage.
  2. "When would you customize vs. configure vs. build from scratch?" → the 4-level OOTB Quotation framework.
  3. "Baseline or CSE — how do you decide, and what are the risks?" → roles/hierarchy tradeoff + upgrade risk on CSE.
  4. "How do you approach performance issues in a JPO/query?" → batch DB calls, avoid loops, HashSet vs StringList, where-clause/expand caution.
  5. Scenario debugging questions on widgets (console/devtools) or JUnit test design (Red-Green-Refactor, layered architecture).
  6. Tooling stack fluency: Eclipse, SonarLint, Git/SVN, Maven/Nexus, Jenkins/GitLab CI, Postman for REST testing, SLF4J for logging.

Good luck — if you want, I can turn any of these sections into flashcards or run a mock Q&A round.

You may like these posts

Post a Comment

Previous Post Next Post