Application Development, Java / JEE

Transcription

1 Application Development, Java / JEE Orsys, with 30 years of experience, is providing high quality, independant State of the Art seminars and hands-on courses corresponding to the needs of IT professionals. Orsys proposes a set of courses on the most important topics in IT technologies and management. Seminars Hands-on courses Design Java/JEE Applications... ( p2 ) Introduction to Object/Java Programming... Best ( p4 ) Java Programming... Best ( p6 ) Java Web Programming... Best ( p8 ) Using the Eclipse Environment... ( p10 ) Swing: developing rich client applications in Java... ( p12 ) Spring framework 3: developing applications... Best ( p13 ) Struts 2: developing MVC Web applications... ( p14 ) ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 1

2 Seminar, 2 day(s) Ref : TEE Participants Technical architects. JEE project leaders. A base Knowledges about object's and multilevel architecture. Next sessions Brussels apr , jun Geneve apr , jun Luxembourg apr , jun Design Java/JEE Applications The Java platform has reached maturity at the server level with the JEE standard. The JEE platform has been in existence for several years now and its reliability is proven. It has demonstrated its robustness for large-scale applications needing to offer high levels of availability. After a presentation of the components of the JEE standard, this seminar analyses the essential points related to designing and deploying a multitier transactional JEE architecture. After this course, the participants will be able to determine which the architectures correspond best to their needs in terms of performance and availability. They will also be able to evaluate the different commercial and Open Source products on the market. 1) Introduction to Java and distributed applications 2) Developing a distributed architecture in Java 3) JEE containers 1) Introduction to Java and distributed applications Java's special features - The Java platform and virtual machines. - Comparison with the other environments. - The different implementations. Distributed architecture - The different tiers. - The components: advantages and disadvantages. - Access to the information system. Transactional architectures - From the transactional need: definition and implementation. - Issues regarding distributed transactions. - Impact on performance. Java integration offer - Interoperability tools. - Evolution of standardisation. Related technologies - The XML galaxy: what, why and how. - Database integration. - The mainframe and Java. 2) Developing a distributed architecture in Java 4) JEE services 5) Overview of the main JEE offers on the market 6) Overview and perspective The JEE "clients" - Web Clients. Applets. Mobile telephone and "fat" client applications. - HTML and other presentation services: current and future. - XML's positioning. Business components - Specialised Java offer. - Alternatives offered by JEE. - Integration to the existing system. Performance and tests - Identifying the metrics and the types of measurements. - How to measure the performance of a multi-tier distributed architecture. - High availability, resistance to breakdowns and the different levels of clustering. - Testing tools. Design Patterns - Definition. - Presentation and benefits of the different models. - Case studies. 3) JEE containers - Role and contributions: reports, multi-threading, transactions, pooling and re-use. - JEE security model. - Transaction support in JEE. - JNDI service for access to resources. - Integrating persistence. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 2

3 - Positioning of the commercial and Open Source offers for the various types of containers. - Deployment packets: Web modules, EJB, connectors and clients. 4) JEE services The components - Enterprise JavaBeans technology. - The various types of EJBs and their role. - Persistence either programmed (BMP) or provided by the container (CMP). - The various architectures: advice and lessons learned. - Standardised transaction support with JTA. - Standardisation of the access to the company's resources with Java Connector Architecture (JCA). - Interaction with other component systems (Corba...). - Importance of a standard for authentication and authorisation (JAAS). Accessing databases - Standardised database access with JDBC. - Interfacing the object model with the relational model. - Optimisation and persistence service. - Accessing directories (LDAP) with JNDI and fundamental role in JEE. Developing Web applications - Extending Web servers with servlets. - The Web presentation layer and its alternatives (JSP, JSF, etc). - Existing models and benefits of frameworks (MVC, Struts, etc). Message-oriented architectures - The Java message service for reliable asynchronous applications with few connections. - Supports for various types of messages with the Java Activation Framework (JAF). XML support - The different XML APIs - The transport protocol SOAP - Presentation of Web services. - Advantages and disadvantages of an XML protocol - Interoperability of Web Services. - UDDI and ebxml standards. 5) Overview of the main JEE offers on the market The various players for a JEE deployment - Purchasing and installing production tools. - Choice of suppliers for products and tools. - Developing JEE clients. - Component suppliers. - Assembling applications. - Deploying applications. - Role of the administrator. Commercial platforms - IBM Websphere, BEA WebLogic, Borland AppServer, Oracle ias, Sun One App Server. Free and commercial JEE bricks - Jboss, Apache Tomcat, Open JMS, Swift MQ, Sonic MQ, Versant, Enjin Toplink 4 java, etc. Development environments - Presentation of the development environment: Eclipse. Roles of JUnit and Apache ANT in the development cycle. UML extensions. - Important criteria for choosing a JEE application server and a development environment. 6) Overview and perspective The participants will benefit from feedback on the different JEE architectures. Which architectures have proved themselves? What are the traps to avoid with regard to new projects? ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 3

4 Hands-on course, 3 day(s) Ref : IPJ Participants Professionals not developing and Project Managers or Business Analysts who want to understand the techniques used by their colleagues or subcontractors. Developers who want to smoothly get used to Object-Oriented Programming. Not any particular knowledge. Next sessions Brussels apr , jun sep Geneve apr , jun sep Luxembourg apr , jun sep Introduction to Object/Java Programming Best In this workshop, the fundamental principles of Object-Oriented Programming are taught through practice. It brings the participants a clear understanding enabling them, according to their needs, to control the technical relationships with their subcontractors, to fully supervise their development teams, or even to better control the construction of object oriented business requirements. It is also often used as a redeployment springboard towards Object-Oriented Programming. 1) General Presentation 2) Syntax, Types and Expressions 3) Methods and Statements 4) Using Abstraction 5) Using Inheritance 6) Using Interface 7) Developing Classes 8) Developing Interfaces 9) Developing Derived Classes 10) Exceptions Each day is split in three theoretical sessions, each followed by simple exercises in which the principles, the use and the development of objects are illustrated. The participants will be able to get used to Eclipse, leader of Java objet development environments. Those exercises will be performed through Windows XP workstations, the JDK 1.5 and Eclipse ) General Presentation - Introduction. - Fundamental principles of Object-Oriented Programming: Abstraction/Encapsulation. - Fundamental principles of Object-Oriented Programming: Inheritance. - General presentation: the Language. - The Tools and the Library. - Releases of Java. 2) Syntax, Types and Expressions - Syntactic structure of a Java application. - Syntax example of a simplified application. - External view of a class: Use Syntax. - Internal view of a class: Implementation Syntax. - Concept of Type. - Compared use of Primitive Types and Object Types. - Simple use of Primitive Types: Integers, Floats, Characters and Booleans. - Concept of Expression. - Examples of Declarations: Variables and Constants. - Compared declarations of Primitive Types and Object Types. - Using Operators with Objects. - Special case of Static Fields or Class Variables. - Conversions between Primitive Types and Object Types. - Code Conventions. 3) Methods and Statements - Syntax of Method Calls. - Class Methods and Instance Methods. - Definition and Use of Methods. - Method Overriding. - Concept of Sub-Block. - Categories of Statements. - Main Control Statements: #if#, #while#, #for#, #return#, #break#. 4) Using Abstraction - Simple example of Use of an Object: Declaration, Instantiation or Creation, Delegation. - Using Object Constructors. - Using the Programming Interface of Objects: example of the Date class. - A very useful class: the String class. - Characteristics of Character Strings. - Using the StringBuffer class: example of use of Method Overloading. 5) Using Inheritance - Reminder of the Inheritance Principle and Terminology. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 4

5 - Using Inheritance. - Example of Inheritance Graph. - The Object class and Genericity. - Using Polymorphism. - Specialization of a Polymorphic Reference. - Typing of References / Typing of Objects. - Behavior of Methods and Typing. - Genericity of Collection Classes: example of the Vector class. - New Features in Java 5 (Tiger): Generics. 6) Using Interface - Implicit/Explicit Interface of a Class. - Syntax of Explicit Interfaces. - Use case of Interface References: Flexibility, Scope Reduction, Polymorphism. - Example of Implementation of Multiple Interfaces. - Synthesis of the benefit of Interfaces for Methods. - Using Interfaces for Constants. - Advanced examples of Use of Interfaces. 7) Developing Classes - Methodological Approach; Static, Dynamic and Business Analysis. - UML Notation: Class, State and Sequence Diagrams. - Class Skeleton: Basic Components, Tools of Code Automatic Generation. - Additional information about Access Rights. - Organizing Packages. - Constraints related to Packages. - Implementing Constructors. - Default Constructor. - Additional information about the Implementation of Constructors. - Self Reference #this#. - Static Fields and Methods. - #main# Method 8) Developing Interfaces - Syntax of Interfaces, case of Constants. - Definition of Interfaces for Methods. - Implementing and Extending Multiple Interfaces. - Partial Implementation of Interface. - Examples and additional information about the Use of Interfaces. 9) Developing Derived Classes - Reminder of the Principles. - Methodological Approach for a Decomposition in Classes. - Abstract Methods and Classes. - Interfaces and Abstract Classes. - Inheritance and Access Rights of Fields. - Inheritance and Call of Constructors. - Overriding and Overloading. 10) Exceptions - Principles and Event Sequence. - Catching and Handling an Exception. - Throwing an Exception. - Unchecked Exceptions. - Simple example with Exception Handling. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 5

6 Hands-on course, 5 day(s) Ref : LJO Participants Developers, engineers, project leaders with close ties to development. A base Knowledges in programming. Experience desirable in application's development. Next sessions Brussels mar , jun sep Geneve mar , jun sep Luxembourg mar , jun sep Java Programming Best This course will allow you to master the principles of the object approach and the features of the Java language. The language constructions will be introduced progressively starting from basic concepts. The course will also cover design problems (via the UML notation) and will present the main standard libraries and APIs: inputs/outputs, utilities, graphics classes (AWT and Swing), applets. This course briefly presents the new Java Tiger features. 1) "Object" techniques 2) An initial language approach 3) Defining and instancing classes 4) Inheritance 5) Exceptions 6) Presentation of some standard classes and libraries 7) New Java Tiger features 8) Conclusion The practical exercises have been designed to illustrate all the elements of the language and to implement the concepts of object-oriented design: all the exercises contain an analysis/design stage followed by a programming stage. 1) "Object" techniques - The general principles of "object" modelling and programming. Abstraction and encapsulation: the interfaces. Various types of inheritance, polymorphism. - An introduction to models and to UML notation: static models, dynamic models, cooperation models, and scenarios. The UML specification for a case study that will be the basis for the exercises that follow. 2) An initial language approach - Variables: declaring and classifying. - Defining fields. - Methods: defining. - Expressions. - Control instructions: conditional, loop, and branch instructions. - Tables. - Compilation Units and packages: controlling the visibility of classes, import mechanisms. A series of simple exercises allowing familiarisation with the development environment and the realisation of a simple programme. Using packages. 3) Defining and instancing classes - Classes and objects. - Fields, methods. - Constructors. - Self-reference. - Static fields and methods. - Aspects of methodology: designing classes. Programming the case study. 4) Inheritance - The different types of inheritance: extension and implementation. - Interfaces and the implementation of interfaces. Polymorphism and its utilisation. - Extension. Defining derived classes, constructors, and references. Aspects of methodology. Constructing hierarchies of classes. Code factorisation: abstract classes. - Simultaneous use of implementation and extension. Abstract classes. Aspects of methodology: Regrouping constants, specifying services. Constructing hierarchies of classes and interfaces. Designing and constructing a hierarchy of classes and interfaces.implementing polymorphism and genericity in the case study. 5) Exceptions ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 6

7 - The try blocks, generating exceptions. - The catch selection algorithm (). - Aspects of methodology: constructing an exception hierarchy, using exceptions. Introducing exceptions into the case study. 6) Presentation of some standard classes and libraries Input/output programming - The hierarchy of input/output classes. - Some file system manipulation classes. - Some input/output classes working on byte flows, character flows. - Keyboard input/output. Graphics programming - Basic concepts: the principles of displaying and managing events from jdk Displaying graphics components: containers and Layouts. - Some graphics components: labels, buttons, text areas. - Handling events: Listeners and Adapters. The relationship of handlers to graphics components. Programming applets - Applets: principles, life cycle, etc. - The Applet class. - Integrating them in a HTML page. Some utility classes - System classes. - Container classes. 7) New Java Tiger features - The new loop instruction. - Enumerated types, autoboxing. - Methods with a variable number of arguments. - Static imports. - Generic types. 8) Conclusion - The first assessments on the language. - The latest trends. - Bibliography items. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 7

8 Hands-on course, 5 day(s) Ref : JSP Goods Knowledges in Java Language and Web's technologies. Experience required in Java programming. Next sessions Brussels jun Geneve jun Luxembourg jun Java Web Programming Best Java has become indispensable for developing server-side Web applications, thanks especially to Servlet and Java Server Page (JSP) technologies. This course will allow you to successfully carry out a company Web project based on the Java platform. You will find out about MVC (Model View Controller) architectures in order to construct solutions that are robust and easy to expand, with, among others, an introduction to development with the help of the Apache Struts environment. The knowledge acquired by practical work on Tomcat, the leading J2EE implementation, as well as on development tools such as Eclipse or WSAD, will allow you to construct your solutions on various Java applications servers such as WebLogic, WebSphere, Jrun or iplanet. 1) Review of the company Web applications environment 2) Development based on servlets 3) Web applications and servlets 4) Presentation of Java Server Pages 5) Tag libraries 6) Accessing databases 7) Introduction to Struts 8) Making the application secure 9) Other development techniques The servlet/jsp container used is Tomcat, the leading J2EE implementation. The development environments are Eclipse and WSAD. 1) Review of the company Web applications environment Basic concepts - Web client and server. Application protocols (HTTP). CGI scripts and managing sessions. - Access to the company's resources: RDBMS, document database and XML, transaction monitor, directory, inherited application. - HTML-XML, Java applets. - The Java 2 Enterprise Edition (J2EE) platform. Multi-tier architecture. 2) Development based on servlets Presentation of the components required for server-side Java use - Web server and server platform. Servlet engine. Java Virtual Machine. Presentation of the development and operating environment - Development and de-bugging tools: NetBeans and Eclipse. - The architecture of Apache's Web container, Tomcat. - Deploying servlets and JSP pages. Developing an initial servlet - Generating dynamic content. The structure of a servlet. 3) Web applications and servlets Developing a Web application based on servlets - The servlet container. The life cycle of a servlet. - Initialising a servlet. Writing the service methods. - Handling HTML forms. - Processing the response, sending information, generating HTML. - Filtering requests/responses. Programming filters. - Retrieving information: from the Web server, the client and the environment. - Invoking other Web resources. Including and transferring control. Handling errors and logging events - Handling execution errors. Handling and using Java exceptions. - Sending http errors. Logging events. Monitoring sessions - The various methods. - Obtaining, consulting and abandoning sessions. The session environment. 4) Presentation of Java Server Pages Presentation of the objectives and the architecture - Objectives. Mechanism of operation. Examples of JSP pages. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 8

9 Development technique - Scriptlets. Integrating them in the Web page. - JSP directives, declarations, expressions and actions. - Versions of the language, XML syntax. Using JavaBeans from JSP pages - Definition, creation, deployment and use. - Accessing and modifying them from a JSP page. Developing applications with the help of JSP - Combining JSP and servlets. Including applets. - Accessing the company's resources. 5) Tag libraries The principle of tag extensions and libraries - Introduction to tag extensions. - Operation. Example of their use. Developing tag extensions - Developing your own tags. Simple tags, with attributes, with a body, embedded. - Deploying and using a tag library. Presentation of JSTL (Java Standard Tag Library) - Designing JSPs with JSTL. Examples. - The various libraries: core, XML, i18n, SQL, functions. 6) Accessing databases Studying an application with access to relational databases - Putting the database and the JDBC interface in place. - Connecting to the database, retrieving information, updating data. - Transaction. Connection pool. - Different connection methods. DataSources: configuring and using them. BDRs/Object models correspondence - Objectives. Java tools and approaches. - Presentation of the SimpleORM (Simple Java Object Relational Mapping) framework 7) Introduction to Struts Using an MVC-type (Model, View, Controller) framework - Presentation. Architecture. The components of the framework. - Handling events. Configuring the application. - Struts Tag Libraries and Extension. 8) Making the application secure - Security in a Web environment. Notions of users, realms, roles. - Authentication and authorisation. - Security and programming servlets. - Installing and configuring SSL. Digital certificates. - Java Authentication and Authorization Service. - Configuring Tomcat. Adding access security to the site constructed. 9) Other development techniques Re-usable framework and package - Uploading files (FileUpload package). - De-bugging/logging (Logging package). - Tests and performance. JUnit, Open Source framework for writing tests. Cactus, server-side test framework. In the pipeline from Sun... - JSF (Java Server Faces), objectives, example. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 9

10 Hands-on course, 2 day(s) Ref : DEC Participants This training is for any Developer, Project Manager or Software Architect. Basic knowledge of the Java language. Next sessions Brussels jun Geneve jun Luxembourg jun Using the Eclipse Environment Eclipse is a very open and modular development platform which can be extended with numerous open source and commercial tools. This two day training focusses on the tools available for Java developers. General concepts are presented. The Java Development Toolkit is described; its edition, compilation, debugging and unit test functionalities are detailed. 1) Introduction 2) Programming with the Java Development Toolkit 3) Unit Testing: JUnit 4) Debugging 1) Introduction - Objectives and principles of Eclipse. - Basic concepts: view, editor, perspective, workspace. - Launching Eclipse. - Managing Views and Perspectives. - Managing Resources (creation, destruction, copy,...). - Project management. Creating projects, managing resources, basic functionalities. 2) Programming with the Java Development Toolkit 5) Controlling Versions: introduction to SVN 6) Automating Tasks: introduction to Maven 7) Configuring Eclipse - Main concepts. - Code organization and code edition. - Completion mechanisms. - Assisted correction mechanisms. - Code generation functionalities. - Refactoring functionalities. - Launching programs. Developing a minimal application using all functionalities provided by the environment. 3) Unit Testing: JUnit - Principles of unit testing. - General presentation of JUnit. - Implementing test cases and test suites. - Launching tests. Testing the application of lab n.2. 4) Debugging - Debug perspective in Eclipse. - Different breakpoints and watchpoints. - Inspecting variables or expressions. - Controlling the execution. - Distributed debugging. Debugging the application of lab n.2. 5) Controlling Versions: introduction to SVN - General concepts of Version Control. - Concepts of projects, revisions, branches, tags, etc. - Main functionalities provided to the developer. - Managing conflicts and branches. - SVN Perspective. Controlling the versions of the application developed in labs n.2, n.3 and n.4. 6) Automating Tasks: introduction to Maven - Fundamental concepts: Project, Target, Task, Property. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 10

11 - Definition of the structure of a project. Dependencies between projects. - Preview of some core tasks:, compilation, archives generation, etc. - The prospects offered by the Maven Eclipse plug-ins. Implementing a Maven project for completing a previous lab. 7) Configuring Eclipse - Managing Preferences Properties. - Installing plug-ins and features. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 11

12 Hands-on course, 4 day(s) Ref : SWI Participants Developers, engineers, project leaders with close ties to development. A base knowledge in programming. Swing: developing rich client applications in Java The inherent cross-platform feature of Java, associated with the emergence of open-source solutions, the need to deploy easily, and the wish to develop advanced functionalities, has contributed to the popularity of the Swing API. In this course, you will learn how to use its components to design and develop rich client applications in Java. 1) Introduction 2) Main containers 3) Main layouts 4) Main components 5) Advanced functions 6) Swing Environments 1) Introduction - History and overview of Swing. Evolutions of the Java GUI toolkits. Basic principles. - Integration with J2SE. MVC platform. - "Lightweight" and "Heavyweight" components. - Introduction of AWT and Java2D, relations with Swing. - Understanding the notions of Layout, LookAndFeel and events. 2) Main containers - Containers used for windows, dialog boxes and panels. - JFrame and JDialog : windows and dialog boxes. - JMenu, JMenuPopup, etc. - JPanel : generic container. - JScrollPane : scrollable container. - JToolBar, JDesktopPane, JFileChooser... Definition of a model of the application. Creating the skeleton with the GUI window, dialog boxes, etc.. 3) Main layouts - Objectives and principles of the layout, for the diposition of displayed elements. - Standard layouts BorderLayout, GridBagLayout... - Use of TableLayout, FormLayout and SwingLayout. - Creating a new layout. Organization of HMI components using layout. 4) Main components - JLabel : integration of plain text or HTML. - Text components : JTextField, JTextArea, JEditorPane. - Buttons : JButton, JComboBox, JCheckBox... - JList, JTree, JTable (models, renderer, editor). 5) Advanced functions - Creation of a component. - Use of actions (toolbars, menu, popup, buttons). - Drag'n Drop mechanism. - Use/Installation and adaptation of a Look & Feel. - Binding framework (jgoodies). - Asynchronous processing with SwingUtilities, SwingWorker. - Internationalization. 6) Swing Environments - Making the work easier by using development environments and APIs. - Frameworks : SwingX, Jide, SwingAppKit. - Introduction of IDE plug-ins. - Deployment with Java Web Start. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 12

13 Hands-on course, 5 day(s) Ref : FSP Participants Java/JEE developers. Good knowledge in Java and JEE. A previous experience in the development of Java/JEE applications recommended. Next sessions Brussels jun , sep Geneve jun , sep Luxembourg jun , sep Spring framework 3: developing applications Best This course will teach you how to use the Spring framework to develop more structured and efficient Java applications, by making easier the configuration of its components as well as its testing, while in the meantime reducing the efforts put in the development. 1) Introduction 2) Implementation of Spring as a light container 3) The Web 1) Introduction - Introduction to the JEE ecosystem. - Spring in this ecosystem, notably compared to EJB. - Best practices in enterprise applications architectures: state-of-the-art. - The role of the light container. - Quality enhancement by unit testing with JUnit and the mocks / stub objects. 2) Implementation of Spring as a light container 4) Implementation of the access to data 5) Integration with other technologies - Support of objects in Spring. - Lifecycle management of the objects taken care of by Spring: the singleton and prototype scopes. - Programming by interface (contract) and low coupling (Strategy pattern). - Dependency injection. - Overview of the various injection strategies. Access to the container. - Configuration by annotations. - Implementation of an Aspect Oriented Programming (AOP) with Spring. - Coupling Spring and JUnit for unit tests. 3) The Web - Using Spring in a Web context. - The MVC / MVC 2 design pattern. - Implementation of the MVC 2 pattern with Spring Web MVC. Introduction of controlers. - Using backing beans and coupling Spring and JSR 303 (bean validation) to validate user inputs. - Securing applications with Spring Security (formerly Acegi). 4) Implementation of the access to data - The Data Access Object layer - Coupling Spring and JDBC (JdbcTemplate). - The stakes of relational mapping. - Coupling Spring and Hibernate. - Transactions management: programmatic, by aspect or by annotation. 5) Integration with other technologies - Spring and the REST Web Services. - Spring and RMI. - Spring and JMX. - Spring and JMS. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 13

14 Hands-on course, 4 day(s) Ref : SRB Participants Java developers involved in the development of a Web user interface. Participants must have a previous experience of programming in Servlet/JSP. Struts 2: developing MVC Web applications This course aims to provide with a comprehensive overview of the Struts 2 framework, in order to use efficiently its capabilities in a rigorous Web application development. All the elements of the architecture will be explained in theory then put into practice with the example of the migration of a Servlet/JSP application in Struts2. 1) Reminder and additional information on the Servlet API 2) The "front controller" in Struts2 3) The value stack and the OGNL expression language 4) Action classes in Struts2 5) The "struts-tags" tag library 6) The "Model Driven" approach 7) Internationalization of a Struts2 application 8) Validation in Struts2 and use of the Tiles framework 1) Reminder and additional information on the Servlet API - Reminder on the basic mechanisms of the Servlet/JSP API: requests life cycle, various scopes, web.xml file. - Additional information on the mechanism of filter and listener used by the Struts2 framework. - Introduction to the Struts2 framework. - Benefits expected compared to Struts1. - Discovery of the basic components of a Struts2 application. 2) The "front controller" in Struts2 - Struts2 configuration files: structure of a struts.xml file, role of the struts.default.xml and struts.properties files. - The "front controller" Struts2 : role of the class FilterDispatcher. - Role of the interceptors: principles, default interceptors. - Configuration rules of the interceptors for an action, creation of stack of interceptors. - The ServletConfigInterceptor interceptor and dependency with the action ("Aware" interfaces). - Creation of our own interceptors. - Execution context of an Action: the ActionContext. 3) The value stack and the OGNL expression language - Roles of the value stack and the OGNL language. - Structure of the value stack and its position in the ActionContext. - Construction rules of OGNL expressions. - Examples of use through JSPs. 4) Action classes in Struts2 - The various action classes: POJO or extension of ActionSupport. - Configuration by default of an action: result values by default and standard types of results. - Mapping of request parameters on the action properties. - Predefined result values and types of predefined results (types of rendering). - Specific configuration of an action: methods of processing and multiple results. - Factorization of results: the "global-results". - Processing of exceptions : the "exception" interceptor, the "exception-mapping" tag. - Factorization of exception processing ("global-exception-mappings"). 5) The "struts-tags" tag library - Structure of the tag library : "control tags ", "data tags", "form ui tags". - The "control-tags": if-elseif-else, append, generator, iterator, merge... - The "data tags" : a, action, bean, date, i18n, include, push, set, text... - The "form ui tags" : hidden, label, passwd, textearea, textfield, token, radio, reset... - Mapping of the "form ui tag" with the properties of the action. - Processing of a file upload : the tag "file", the interceptor "fileupload", implementation of the action. 6) The "Model Driven" approach - Objectives of the "Model Driven" approach. - Components: the "model-driven" and "scoped-modeldriven" interceptors, specific configuration ("scopedmodeldriven"). - CRUD implementation in Struts2: "customizable" interceptor, configuration of action with parameters. - Example of implementation. 7) Internationalization of a Struts2 application - Principles of the internationalization of an application (struts2 resources bundle). ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 14

15 - Struts2 components: the "i18n" interceptor, the "request_locale" parameter and the "locale" variable of the user. - Search policy of a "resource bundle". - The ActionSupport class and the various gettext() methods. - Parametrized ".properties" file. - The "form ui tags" using the internationalization. 8) Validation in Struts2 and use of the Tiles framework - Principles of validation (client and server side). - Struts2 components: the "validation" interceptor, the "Validateable" and "ValidationAware" interfaces. - Validation on the "client" side: "validate" property of the form, generated javascript. - Working with themes. Existing themes. Creating a customized theme. - Principle of the "Composite View" pattern and the Tiles framework. - The "tag-tiles" tag library: development of layouts and page fragments. - Configuration of the actions using Tiles pages: the result-type "tiles". Integration of Tiles in Struts2. - Other aspects of the framework. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 15

16 Hands-on course, day(s) Ref : MUC Participants Good knowledge of one of the three languages aimed in this course (Java, C#, C++). Basic knowledge on concepts of multicore development. At the end of this course you'll have a better comprehension of Multicore architecture and programming: multithreaded and multi process design techniques are presented along with languages dedicated to parallel task programming. You'll also deal with synchronization constraints and, especially on how to avoid issues when manipulating data. 1) Introduction 2) Application Design 3) Threads 4) Process 5) Parallel task programming 6) Conclusion BOUML, an open source application, will be used for UML design; Visual Studio express#for C# and C++ programming; NetBeans# 6.x for Java. All demonstration samples will be based on UML, Java, C++ and DOT Net. 1) Introduction - The stakes of Multicore Programming in coming years. - General view on technologies that will be used: processes, threads parallelism. - Reminder of how a processor works. - #Hyper threaded# architecture. - INTEL# and AMD# processor architecture. - Nvidia# and ATI# architecture. - Preparing for synchronization aspects: common cases. 2) Application Design - Design importance. - Parallel Tasking (ex: calculation). - Use of asynchronous mechanisms: processes, threads... - From scratch application development: precautions and design. - Avoiding #singletons#. - Modifying an existing Multicore application: some of the issues. - Making a correct choice of architecture: good balance between synchronization and performance. - Choosing between multiprocess and multithread design. 3) Threads - Thread organization in a system. - Threads in systems and languages (sample: Java,.NET and C++). - Thread contribution to industry applications. - Thread scheduling in systems: #round robin# algorithm. - Stacks management and #call stack# in threads. - Multithreaded debuggers: ex Visual Studio andnetbeans#. - Synchronization management objects: critical sections, Mutexesand Semaphores. - #Thread safe# development. - Development rules for multithreaded applications. - Threading API in Windows, Java and DOT Net. - POSIXAPI. Threads and synchronization in DOT Net, Java and C++. 4) Process - Memory addressing in processes. - Multi process approach criteria. - Overview of Inter Process Communication (IPC) techniques. - Debugging Multi Process applications;new tools (ex: Visual Studio 2005). - Multi Process: benefits and drawbacks of the technique. - Unique feature: #AppDomain# in DOT Net. Asynchronous tasks management through Windows API. 5) Parallel task programming - Features and aims of parallel tasking. - #Parallel FX#: the DOT Net library for parallel tasking. - PFX architecture and spirit. - TPL componentsand PLINQ. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 16

17 - C++ #OpenMp# library. - Available #OpenMP# directives. - Using graphical devices GPU for calculations. - Nvidia (CUDA) and ATI developer kits. - Applications samples that use the libraries. - Code sample and comments. Feature parallelized algorithms with PFX C#. Create parallelized algorithms with #OpenMP# and C++. 6) Conclusion - Review of studied techniques. - Multicore and the future of C++. - Synthesis of design, threads, multiprocess and parallel tasking features. ORSYS, La Grande Arche, Paroi Nord, Paris La Défense cedex. Tél : +33 (0) Fax : +33(0) page 17