Srini Penchikala

Application Architecture Trends - Where We Have Been, Where We Are Going

Java Application Architecture is going through a major paradigm shift in terms of design techniques, technologies, and frameworks that are used to build and deploy Java applications. Enterprise JavaBeans (EJB), traditional Message Queues (JMS), and even Application Servers as we know them are being replaced by light-weight POJO based frameworks such as Spring, ActiveMQ, and OSGi compatible containers.

This technical session will give an overview of Java application architectures of the past where EJB's, verbose EAR files and heavy-weight J2EE application servers were the only choice a Java developer had to develop and implement Java applications to the current pragmatic architectures where the concepts like POJO's and Domain Driven Design (DDD) have become the core design and development concerns like they should be. The presentation will also include a discussion on how concerns like Persistence, Transaction Management, Application Security and Asynchronous Messaging have become the infrastructure concerns that are managed by the frameworks (like Spring) out-of-the-box instead of developers having to spend a lot of time and effort in programming or dealing with complex configuration files and deployment descriptors for implementing these concerns.

The presentation will talk about the emerging design techniques like Domain Driven Design, Domain Specific Languages (DSL), Custom Annotations, Dependency Injection (DI), Aspect-Oriented Programming (AOP) and OSGi. I will also discuss the use cases where these techniques add value to the architecture and where they may be just an overkill.

Domain Driven Design & Development with Spring Portfolio

In this technical session, I will discuss Domain Driven Design and Development from a practical implementation stand-point. The presentation looks at various architectural and design factors, best practices, frameworks and tools that affect the design of a business domain implementation project. It also covers the impact of various design concerns like Dependency Injection (DI), Aspect Oriented Programming (AOP), Persistence, Caching, Transaction Management and Application Security in Domain Modeling and Domain Driven Design problem space. The session also provides the domain model and code examples based on a real world DDD implementation project that utilized agile software development techniques such as SCRUM, Test Driven Development and Refactoring to realize a great success in completing the project on time and under budget.

Architecture Rules Enforcement using Aspects

Even though many companies have some kind of application architecture standards, they don't usually have a mechanism to enforce those standards. As a result of this lack of architecture governance, the Implementation (Code) often doesn't match the Requirements (Reference Architecture). Enforcing Reference Architecture guidelines promotes consistency and modularity in the System. It also helps in detecting structural complexity and preventing it earlier in the software development process. As a result, the application code is modifiable, portable, and testable.

In this presentation, I will talk about the significance of enforcing the architecture rules and standards and how to actually enforce them in software development projects. I will start off the discussion explaining various types of architecture rules that range from simple module dependencies to enforcing how APIs and specific idioms should be used. All these rules usually fall into categories such as Layered Architecture, Separation Of Concerns, Domain Driven Design, and Infrastructure. Some of the rules examples will include basic validations like DAO (Persistence) layer shouldn't depend on any other layers, Presentation layer should not use DAO classes directly, and Service layer should never call web layer. Separation of concerns rules are no transaction management in DAO classes and Service layer should be transactional. More sophisticated rules like that are used in a Domain Driven Design project such as Service object creation through a Factory object (i.e. no Service instantiation using the new keyword), No direct access to DAO's except from the Domain classes (go through Domain or Repository objects), and Business service that fails with a concurrency related failure can be retried.