Blogs
Will Ezell
Chief Technology Officer

Java Under The Hood, But Don’t Think You Need Java Skills

Feb 19, 2020

By: Will Ezell

We’ve already covered the benefits of a Java CMS in the past. Now, we’ll break down all the ways that Java and its related technologies are the ideal architecture for an innovative content management platform like dotCMS. These architecture choices, in turn, make dotCMS the enterprise-grade open source CMS that Java developers enjoy working with.

While dotCMS requires very little Java skills to implement the platform, for those operating a Java shop here are some of the most interesting areas of dotCMS to explore.

Flexible Environments

dotCMS abstracts data storage away for maximum flexibility when choosing database technologies. That means the platform code is portable across many different database solutions out of the box. dotCMS supports the most popular technologies like Oracle, SQL Server, PostgreSQL, and MySQL by default. For large enterprises, in particular, the ability to leverage the knowledge of their existing database administrators is paramount. dotCMS, therefore, is designed from the ground up to be database independent.

This flexibility extends to the operating system as well. That’s because dotCMS can be deployed to nearly any application server running on the Java Virtual Machine (JVM). Most operating systems can run the Java Runtime Environment (JRE) and have an enterprise-grade application server option available, whether it’s Windows or any variation of Linux. That means enterprises can use their current environments or spin up similar ones that their IT operations teams are familiar with to save the time and expenses incurred when finding specialized tech talent.

All of this said, dotCMS recognizes development teams are moving towards containerization as a truly cross-platform deployment model. That’s why dotCMS recently added native support for Docker and containerized deployments out of the box.

Extensibility & Interoperability

dotCMS enables developers to extend the platform with new capabilities to support specific use-cases, using OSGi plugins out-of-the-box. The platform has a plugin architecture that supports OSGi, which is an enormous time-saver for Java developers and allows development teams to cleanly add new functionality without creating issues with the core product. That’s because OSGi bundles are self-contained software components that only expose what’s necessary to minimize dependency requirements. And enterprise Java developers are well aware that resolving dependency conflicts is a nightmare for most Java applications.

Further Reading: OSGI Explained: Extending Your Software to Embed an OSGi Framework

While dotCMS provides OSGi support for both extensibility and interoperability, the platform also exposes a full Java API with corresponding Javadocs. Using this, developers can deeply integrate third-party systems with the core dotCMS codebase. That’s not to mention the custom workflow actions that Java developers can create to connect to external systems and trigger workflow steps automatically. This additional functionality can be added on the fly as a dynamic OSGi plugin, or during the platform’s compilation as a static plugin. Static plugins, however, are primarily used to override configurations and Java classes within the core dotCMS code itself.

Read On: What is Interoperability: Web Content Management Edition

Easy Deployments & Scaling

dotCMS can be compiled as a WAR file and deployed to a wide range of application servers with minimal configuration changes. That means enterprises can continue using their existing Java environments, whether it's Tomcat, JBoss/Wildfly, or WebLogic. And when using new OSGi plugins, IT teams can deploy new bundles without needing to redeploy the entire core platform. These capabilities make dotCMS ideal for flexible deployments across platforms and environments.

Along with quick deployments, dotCMS has a microservices architecture that enables different components to scale independently. This architecture in combination with J2EE makes the platform ideal for distributing workloads amongst multiple instances. That means dotCMS can easily scale horizontally across many servers — especially when running dotCMS in the cloud. dotCMS has recently taken this a step further with containerized deployments by providing native support for Docker and Kubernetes. Using these tools, IT operations teams can automate the deployment of dotCMS components for optimal elasticity. dotCMS, therefore, is ready for the high-traffic global deployments that enterprises require.

Further Reading: The Benefits of Containers: Security, Speed & Microservice Compatibility

Streamlined Development

The microservices architecture of dotCMS is beneficial for more than just scaling, however, because the approach can also enable a more Agile software development cycle. Building smaller, highly specific components often leads to faster development times and higher quality-results than the monolithic approach. That’s because monolithic applications usually have large codebases that are challenging for developers to learn, and these applications don’t easily integrate into DevOps processes like the CI/CD pipeline or containerization and orchestration. The ability to get new features to marketer faster is critical for organizations pursuing innovative digital ambitions.

Read More: What Are Microservices, And How Do They Aid Agile Development?

dotCMS also provides a large set of REST APIs and native GraphQL support but realized that these still may not be enough for some organizations that have highly specific business requirements. That’s why the platform also allows custom scripted endpoints and Scripting as a Service using Velocity. Beyond this, however, is the ability for developers to create custom Viewtools using Java to make additional complex functional available to frontend developers within their Velocity scripts. This further streamlines the development of new frontend apps by empowering developers to utilize low code tooling as much as possible.

dotCMS Leverages The Java Ecosystem

dotCMS is built atop a number of Java-based technologies to reduce the learning curve for developers to get started with the platform. That’s because the Java ecosystem is full of high-quality, enterprise-grade tooling that’s well-documented and familiar for most Java developers. There’s a reason Java has been one of the most popular programming languages for decades.

As you can see, dotCMS leverages Java technologies for most aspects of the system, from development and customization to data storage and deployments. dotCMS aims to be one of the most developer-friendly solutions on the market while reducing the need for heavy development altogether with its robust set of low code and NoCode capabilities. These architecture choices make dotCMS the ideal solution for enterprises.

From a development standpoint, Java is a game-changer for building out an interconnected best-of-breed DXP. Learn more about OSGi and other powerful dotCMS integration capabilities with our report: How dotCMS Enables Interoperability & Extensibility.

Filed Under:

Recommended Reading

Headless CMS vs Hybrid CMS: How dotCMS Goes Beyond Headless

What’s the difference between a headless CMS and a hybrid CMS, and which one is best suited for an enterprise?

Exploring TimeMachine: How dotCMS Handles Content Versioning

With dotCMS, tools like TimeMachine and Workflow Management help enterprises control content versioning, content edits, user permissions, workflows and more.

Digital Ambition Requires Ambitious Technology

When it comes to the content foundation of a digital experience platform, critical capabilities are reasonably straightforward. There are only four, really - since security, scalability and containeri...