Chris Richardson is a developer and architect with over 20 years of experience. He is the author of POJOs in Action, which describes how to build enterprise Java applications with POJOs and lightweight frameworks such as Spring and Hibernate. Chris has been a technical leader at Insignia, BEA, and elsewhere and recently was nominated a Java Champion.
His technical interests include domain-driven design, aspect-oriented programming, object/relational mapping, agile development and developer testing. Chris has spoken at various conferences including No Fluff Just Stuff Java Symposium, SD West, JavaPolis, SpringOne, the Colorado Software Summit and JavaOne. He is also the co-chair of the East Bay Java SIG. Chris has a degree in Computer Science from the University of Cambridge, England.
Chris Richardson discusses the evolving cloud computing landscape, cloud computing tools, difference between local machines and cloud-based virtual machines, Cloud Foundry offerings, deploying a Java application to Cloud Foundry, Cloud Foundry vs other offerings, future Cloud Foundry developments, and the future of enterprise Java development.
We have all been frustrated by difficult to maintain code. Some code is difficult to maintain because it does too much - e.g. handling transactions, persistence and security, as well as implementing business rules. Changing that kind of code requires you to understand and tackle many different concerns. Other code might be difficult to maintain because the implementation of a particular feature (e.g. audit logging) is scattered throughout the code base. Changing the implementation of that kind of feature involves changing many components. This talk describes how to improve the maintainability of enterprise Java applications by using dependency injection, and Aspect Oriented Programming. We will show how you can implement business logic using POJOs that are decoupled from infrastructure concerns such as persistence, security and transaction management. We will also describe how to modularize concerns such as audit logging that are normally implemented by code that is mixed in with the business logic. The presentation has numerous Spring and AspectJ examples.
Computer hardware has traditionally been a scarce, expensive resource. In the early days of computing developers had to share a single machine. Today, each developer usually has their own machine but it's rare for a developer to have more than one. This means that running performance tests often involves scavenging for machines. Likewise, replicating even just part of a production environment is a major undertaking. With Amazon's Elastic Compute Cloud (EC2), however, things are very different. A set of Linux servers is now just a web service call away. Depending on the type of the servers you simply pay 10-80 cents per server per hour for up to 20 servers! No more upfront costs or waiting for machines to be purchased and configured. In this presentation you will learn about EC2Deploy, which is an open-source framework that I've developed for deploying an enterprise Java application on a set of Amazon EC2 servers. We will talk about how to use EC2 to boost developer productivity and reduce hardware cost. You will learn how developers and testers can use EC2 for load testing and exploring failover scenarios. We will also discuss the benefits and drawbacks of using EC2 and other Amazon web services such as the Simple Storage Service (S3) in your production environment. You will also hear about our experiences writing the EC2 deployment framework in Groovy.
Traditionally, computer hardware was a scarce, expensive resource. Running performance tests often meant scavenging for machines around the office. Today, however, things are different. With Amazon's EC2 a cluster of servers is now just a web service call away. In this presentation you will learn about design and implementation of a Groovy-based framework for load testing Java EE applications on EC2. This framework provides a simple (internal) DSL for configuring a cluster (database+web container+apache), deploying a web application and running performance tests using JMeter. You will learn about capabilities of EC2 and how to use it in your development efforts. We describe how we Amazon S3 to workaround EC2's lack of a persistent file system and avoid time-consuming uploads of WAR files. You will also learn how Groovy helped and hindered with the development of the framework.
These presentations provides an overview of Amazon EC2, describes how to run Java EE applications on EC2 and discusses Cloud Tools, which is an open-source framework for deploying Java EE applications on EC2. There are three main parts to Cloud Tools: Amazon Machine Images (AMIs) that are configured to run Tomcat and work with EC2Deploy EC2Deploy - the core framework. This framework manages EC2 instances, configures MySQL, Tomcat, Terracotta and Apache and deploys the application. Maven and Grails plugins that use EC2Deploy to deploy an application to EC2.
Some code is downright scary to maintain. An all too common example are bloated service methods that do too much: manage transactions, handle security as well as implement the business rules. Changing that kind of code requires you to understand and tackle many different concerns. Code can also be difficult to maintain if the implementation of some features (e.g. audit logging) is scattered throughout the code base. Changing that kind of code involves changing many components. This talk describes how to improve your code with real objects and aspects. We show how to use AOP to simplify your code by modularizing concerns such as audit logging that are normally implemented by code that is mixed in with the business logic. We also describe how to write truly object-oriented code in Java - something which is not done as often as you might expect even though Java is an object-oriented language. We will compare and contrast a procedural design with an object- oriented design and describe the benefits of using real objects. We will also show how to refactor a procedural design into an object-oriented design an easy way to eliminate those fat service methods and improve the design of your application.
Chris gives a presentation that covers useful techniques that he has used over the years to write fast running automated tests for enterprise Java applications.
Java is an object-oriented language and object-oriented design is considered by many to be a good way to tackle complexity. However, surprisingly many complex enterprise Java applications are written in a procedural style. The business tier consists of fat services and anemic domain models and consequently can be difficult to understand, maintain and test. In this presentation, you will learn about how to improve your applications by implementing business logic using rich POJO domain model. We will compare and contrast a procedural design with an object-oriented design and describe the benefits of using an object-oriented approach. You will learn how to identify procedural code smells and eliminate them by refactoring your code - something you can start doing the Monday morning after the conference.
The Spring framework has an extremely rich set of features that span all tiers of the application. If you are relatively new to Spring you might be wondering which of the many features to focus on, which features to avoid, and how to use the various features together in an application. This talk describes how the Spring framework was used to build an enterprise Java application. We will walk through each tier of the application and describe how the Spring framework was used. You will learn about how Spring was used to solve various design issues including: - wiring application components together - handling crosscutting concerns including transactions, audit logging, and security - simplifying database access - testing.
Chris did this presentation with Kito Mann, author of JavaServer Faces in Action. In this presentation, they describe how JSF, Spring and Hibernate can be used to build an enterprise Java application. The example application that they cover is called Project Track, which is now an open-source project. Here is an overview of Project Track. Kito and Chris are also jointly teaching a JSF, Spring and Hibernate class.
The Repository pattern is one of the patterns described in the excellent book Domain-Driven Design by Eric Evans. A repository is a class that provides the illusion of an in-memory collection of objects and has methods for adding and removing objects and finding objects that match some criteria. The collection of objects managed by a repository almost always resides in the database. As simple as the idea sounds, it's one of the most frequently discussed topics on the domain-driven design mailing list. Here is a description of how to implement repositories.
The goal of Project Track is to show how to build enterprise Java applications with JSF, Spring, Hibernate and Acegi Security. Project Track was originally written by Kito Mann (author of JavaServer Faces in Action). Chris Richardson (author of POJOs in Action), then developed the Spring, and Hibernate backend, integrated Acegi Security, and wrote some Selenium tests (among other things).
Servlets and JSP pages are very effective technologies for building the presentation layer of an application that support both traditional web browsers and newer wireless handheld devices. They are a platform independent standard supported by multiple vendors and are considerably easier to use and more efficient than older technologies such as CGI scripts. In the Java 2 Platform Enterprise Edition (J2EE) architecture J2EE, servlets and JSP pages are referred to as web components and handle HTTP requests from clients, invoke components in the business logic layer (typically enterprise java beans), and generate responses that are usually HTML or XML documents.
Content
