Rational application developer V6 programming guide / John Ganci ... [et al.].

CONTENIDO
Part 1. Introduction to Rational Application Developer
Chapter 1. Introduction
1.1. Introduction and concepts
1.2. Product packaging
1.3. Product features
1.4. Sample code
Chapter 2. Programming technologies
2.1. Desktop applications
2.1.1. Simple desktop applications
2.1.2. Database access
2.1.3. Graphical user interfaces
2.1.4. Extensible Markup Language (XML)
2.2. Static Web sites
2.2.1. Hypertext Transfer Protocol (HTTP)
2.2.2. HyperText Markup Language (HTML)
2.3. Dynamic Web applications
2.3.1. Simple Web applications
2.3.2. Struts
2.3.3. JavaServer Faces (JSF) and Service Data Objects (SDO)
2.3.4. Portal applications
2.4. Enterprise JavaBeans
2.4.1. Different types of EJBs
2.4.2. Other EJB features
2.4.3. Requirements for the development environment
2.5. J2EE Application Clients
2.5.1. Application Programming Interfaces (APIs)
2.5.2. Security
2.5.3. Naming
2.5.4. Deployment
2.5.5. Requirements for the development environment
2.6. Web Services
2.6.1. Web Services in J2EE V1.4
2.7. Messaging systems
2.7.1. Java Message Service (JMS)
2.7.2. Message-driven EJBs (MDBs)
2.7.3. Requirements for the development environment
Chapter 3. Workbench setup and preferences
3.1. Workbench basics
3.1.1. Workspace basics
3.1.2. Rational Application Developer log files
3.2. Preferences
3.2.1. Automatic builds
3.2.2. Clean build (manual)
3.2.3. Capabilities
3.2.4. File associations
3.2.5. Local history
3.2.6. Perspectives preferences
3.2.7. Internet preferences
3.3. Java development preferences
3.3.1. Java classpath variables
3.3.2. Appearance of Java elements
3.3.3. Code style and formatting
3.3.4. Compiler options
3.3.5. Java editor settings
3.3.6. Installed JREs
3.3.7. Templates
3.3.8. Code review
Chapter 4. Perspectives, views, and editors
4.1. Integrated development environment (IDE)
4.1.1. Rational Application Developer online help
4.1.2. Perspectives
4.1.3. Views
4.1.4. Editors
4.1.5. Perspective layout
4.1.6. Switching perspectives
4.1.7. Specifying the default perspective
4.1.8. Organizing and customizing perspectives
4.2. Available perspectives
4.2.1. CVS Repository Exploring perspective
4.2.2. Data perspective
4.2.3. Debug perspective
4.2.4. Generic Log Adapter perspective
4.2.5. J2EE perspective
4.2.6. Java perspective
4.2.7. Java Browsing perspective
4.2.8. Java Type Hierarchy perspective
4.2.9. Plug-in Development perspective
4.2.10. Profiling and Logging perspective
4.2.11. Resource perspective
4.2.12. Team Synchronizing perspective
4.2.13. Test perspective
4.2.14. Web perspective
4.2.15. Progress view
4.3. Rational Product Updater
Chapter 5. Projects
5.1. J2EE architecture
5.1.1. EAR files
5.1.2. WAR files
5.1.3. EJB JAR files
5.1.4. J2EE Application Client JAR files
5.1.5. RAR files
5.2. Projects and folders
5.3. Rational Application Developer projects
5.3.1. Enterprise Application project
5.3.2. J2EE Application Client project
5.3.3. Dynamic Web Project
5.3.4. Static Web Project
5.3.5. EJB project
5.3.6. Connector project
5.3.7. Java project
5.3.8. Simple project
5.3.9. Server project
5.3.10. Component test project
5.3.11. Checkout projects from CVS
5.4. Creating a new project
5.5. Project properties
5.6. Rational Application Developer samples
5.6.1. The samples gallery
Part 2. Develop applications
Chapter 6. RUP and UML
6.1. Overview
6.2. Rational Unified Process (RUP)
6.2.1. Process Advisor
6.2.2. Process Browser
6.2.3. Setting process preferences
6.3. Visualize applications with UML
6.3.1. Unified Modeling Language (UML)
6.3.2. Browse diagram
6.3.3. Topic Diagram
6.3.4. Static Method Sequence Diagram
6.3.5. Class Diagram
6.3.6. Sequence Diagram
6.3.7. J2EE visualization
6.4. More information on UML
Chapter 7. Develop Java applications
7.1. Java perspective overview
7.1.1. Package Explorer view
7.1.2. Call Hierarchy view
7.1.3. Type Hierarchy view
7.1.4. Problems view
7.1.5. Declaration view
7.1.6. Code review
7.1.7. Outline view
7.1.8. Diagram Navigator view
7.2. Develop the Java Bank application
7.2.1. Java Bank application overview
7.2.2. Create a Java Project
7.2.3. Create a class diagram
7.2.4. Create Java packages
7.2.5. Create a Java interface
7.2.6. Create Java classes
7.2.7. Create the Java attributes and accessor methods
7.2.8. Add method declarations to an interface
7.2.9. Add Java methods and constructors
7.2.10. Define relationships (extends, implements, association)
7.2.11. Implement the methods for each class
7.2.12. Run the Java Bank application
7.3. Additional features used for Java applications
7.3.1. Locating compile errors in your code
7.3.2. Running your programs
7.3.3. Debug your programs
7.3.4. Java Scrapbook
7.3.5. Pluggable Java Runtime Environment (JRE)
7.3.6. Add a JAR file to the classpath
7.3.7. Export the Java code to a JAR file
7.3.8. Run the Java application external to Application Developer
7.3.9. Import a Java JAR file into a project
7.3.10. Utility Java Projects
7.3.11. Javadoc
7.4. Java editor and Rapid Application Development
7.4.1. Navigate through the code
7.4.2. Source folding
7.4.3. Type hierarchy
7.4.4. Smart Insert
7.4.5. Mark occurrences
7.4.6. Word skipping
7.4.7. Smart compilation
7.4.8. Java search
7.4.9. Working sets
7.4.10. Quick Assist (Quick Fix)
7.4.11. Code Assist (content)
7.4.12. Import generation
7.4.13. Generate getters and setters
7.4.14. Override/implement methods
7.4.15. Adding constructors
7.4.16. Refactoring
Chapter 8. Develop Java database applications
8.1. Introduction to Java database programming
8.1.1. JDBC overview
8.1.2. Data source versus direct connection
8.1.3. XMI and DDL
8.1.4. Rational Application Developer database features
8.2. Preparing for the sample
8.2.1. Import the BankDB sample project
8.2.2. Set up the BANK sample database
8.3. Data perspective
8.3.1. Data Definition view
8.3.2. Database Explorer view
8.3.3. DB Output view
8.3.4. Navigator view
8.4. Create databases and tables from scripts
8.4.1. Create a database
8.4.2. Create a database connection
8.4.3. Create the database tables from scripts
8.4.4. Populate database tables with data
8.5. Create and work with database objects
8.6. UML visualization
8.6.1. Class diagrams
8.6.2. Information engineering (IE) diagrams
8.6.3. IDEF1X (Integrated Definition Extended) diagrams
8.7. Create SQL statements
8.7.1. Using the SQL Statement wizard
8.7.2. Using the SQL Query Builder
8.8. Access a database from a Java application
8.8.1. Prepare for the sample
8.8.2. Access the database using the DriverManager
8.8.3. Access using a data source
8.9. Java stored procedures
8.9.1. Prepare for the sample
8.9.2. Create a Java stored procedure
8.9.3. Build a stored procedure (deploy to database)
8.9.4. Java DriverManager access to a Java stored procedure
8.9.5. JavaBean access to Java stored procedure
Chapter 9. Develop GUI applications
9.1. Introduction to the Visual Editor
9.2. Prepare for the sample
9.2.1. Create the project for the sample
9.2.2. Add JDBC driver for Cloudscape to project
9.2.3. Set up the sample database
9.2.4. Import the model classes for the sample
9.3. Launching the Visual Editor
9.3.1. Create a visual class
9.3.2. Open an existing class with the Visual Editor
9.4. Visual Editor overview
9.4.1. Visual Editor layout
9.4.2. Customizing the appearance of the Visual Editor
9.5. Work with the Visual Editor
9.5.1. Resize a JavaBean component
9.5.2. Code synchronization
9.5.3. Changing the properties of a component
9.5.4. Add JavaBeans to a visual class
9.5.5. Work with the Properties view
9.5.6. Testing the appearance of the GUI
9.5.7. Add event handling to GUI
9.5.8. Verify the Java GUI application
9.5.9. Run the sample GUI as a Java application
9.5.10. Automatically add event handling
9.5.11. Visual Editor binding
Chapter 10. Develop XML applications
10.1. XML overview and technologies
10.1.1. XML and XML processor
10.1.2. DTD and XML schema
10.1.3. XSL and XSLT
10.1.4. XML namespaces
10.1.5. XPath
10.2. Rational Application Developer XML tools
10.2.1. Create a project for XML sample
10.2.2. Work with DTD files
10.2.3. Work with XML schema files
10.2.4. Work with XML files
10.2.5. Work with XSL files
10.2.6. Transform an XML file
10.2.7. Java code generation
10.3. Where to find more information
Chapter 11. Develop Web applications using JSPs and servlets
11.1. Introduction to Web applications
11.1.1. Concepts and technologies
11.1.2. Model-view-controller (MVC) pattern
11.2. Web development tooling
11.3. Prepare for the sample
11.3.1. ITSO Bank Web application overview
11.3.2. Create a Web Project
11.3.3. Web Project directory structure
11.3.4. Import the ITSO Bank model
11.4. Define the site navigation and appearance
11.4.1. Launch the Web Site Designer
11.4.2. Create a new page template
11.4.3. Customize a page template
11.4.4. Customize a style sheet
11.4.5. Create the Web site navigation and pages
11.4.6. Verify the site navigation and page templates
11.5. Develop the static Web resources
11.5.1. Create the index.html page content (text, links)
11.5.2. Create the rates.html page content (tables)
11.5.3. Create the insurance.html page content (list)
11.5.4. Create the redbank.html page content (forms)
11.6. Develop the dynamic Web resources
11.6.1. Creating model classes
11.6.2. Working with servlets
11.6.3. Working with JSPs
11.7. Test the application
11.7.1. Prerequisites to run sample Web application
11.7.2. Run the sample Web application
11.7.3. Verify the sample Web application
Chapter 12. Develop Web applications using Struts
12.1. Introduction to Struts
12.1.1. Model-view-controller (MVC) pattern with Struts
12.1.2. Rational Application Developer support for Struts
12.2. Prepare for the sample application
12.2.1. ITSO Bank Struts Web application overview
12.2.2. Create a Dynamic Web Project with Struts support
12.2.3. Add JDBC driver for Cloudscape to project
12.2.4. Set up the sample database
12.2.5. Configure the data source
12.3. Develop a Web application using Struts
12.3.1. Create the Struts components
12.3.2. Realize the Struts components
12.3.3. Modify ApplicationResources.properties
12.3.4. Struts validation framework
12.3.5. Page Designer and the Struts tag library
12.3.6. Using the Struts configuration file editor
12.4. Import and run the Struts sample application
12.4.1. Import the Struts Bank Web application sample
12.4.2. Prepare the application and sample database
12.4.3. Run the Struts Bank Web application sample
Chapter 13. Develop Web applications using JSF and SDO
13.1. Introduction to JSF and SDO
13.1.1. JavaServer Faces (JSF) overview
13.1.2. Service Data Objects (SDO)
13.2. Prepare for the sample
13.2.1. Create a Dynamic Web Project
13.2.2. Set up the sample database
13.2.3. Configure the data source via the enhanced EAR
13.3. Develop a Web application using JSF and SDO
13.3.1. Create a page template
13.3.2. Useful views for editing page template files
13.3.3. Customize the page template
13.3.4. Create JSF resources using the Web Diagram tool
13.3.5. Edit a JSF page
13.3.6. Completing the SDO example
13.4. Run the sample Web application
13.4.1. Prerequisites to run sample Web application
13.4.2. Run the sample Web application
13.4.3. Verify the sample Web application
Chapter 14. Develop Web applications using EGL
14.1. Introduction to EGL
14.1.1. Programming paradigms
14.1.2. IBM Enterprise Generation Language
14.1.3. IBM EGL and Rational brand software
14.1.4. IBM EGL feature enhancements
14.1.5. Where to find more information on EGL
14.2. IBM EGL tooling in Rational Developer products
14.3. Prepare for the sample application
14.3.1. Install the EGL component of Rational Application Developer
14.3.2. Enable the EGL development capability
14.3.3. Install DB2 Universal Database
14.3.4. Create an EGL Web Project
14.3.5. Set up the sample database
14.3.6. Configure EGL preferences for SQL database connection
14.3.7. Configure the data source
14.3.8. Configure the DB2 JDBC class path environment variables
14.4. Develop the Web application using EGL
14.4.1. Create the EGL data parts
14.4.2. Create and customize a page template
14.4.3. Create the Faces JSPs using the Web Diagram tool
14.4.4. Add EGL components to the Faces JSPs
14.5. Import and run the sample Web application
14.5.1. Import the EGL Web application sample
14.5.2. Prerequisites
14.5.3. Generate Java from EGL source
14.5.4. Run the sample EGL Web application
14.6. Considerations for exporting an EGL project
14.6.1. Reduce the file size of the Project Interchange file
14.6.2. Manually adding the runtime libraries after migration
14.6.3. Export WAR/EAR with source
Chapter 15. Develop Web applications using EJBs
15.1. Introduction to Enterprise JavaBeans
15.1.1. What is new
15.1.2. Enterprise JavaBeans overview
15.1.3. EJB server
15.1.4. EJB container
15.1.5. EJB components
15.2. RedBank sample application overview
15.3. Prepare for the sample
15.3.1. Required software
15.3.2. Create and configure the EJB projects
15.3.3. Create an EJB project
15.3.4. Configure the EJB projects
15.3.5. Import BankBasicWeb Project
15.3.6. Set up the sample database
15.3.7. Configure the data source
15.4. Develop an EJB application
15.4.1. Create the entity beans
15.4.2. Create the entity relationships
15.4.3. Customize the entity beans and add business logic
15.4.4. Creating custom finders
15.4.5. Object-relational mapping
15.4.6. Implement the session facade
15.5. Testing EJB with the Universal Test Client
15.6. Adapting the Web application
Chapter 16. Develop J2EE application clients
16.1. Introduction to J2EE application clients
16.2. Overview of the sample application
16.3. Preparing for the sample application
16.3.1. Import the base enterprise application sample
16.3.2. Set up the sample database
16.3.3. Configure the data source
16.3.4. Test the imported code
16.4. Develop the J2EE application client
16.4.1. Create the J2EE application client projects
16.4.2. Configure the J2EE application client projects
16.4.3. Import the graphical user interface and control classes
16.4.4. Create the BankDesktopController class
16.4.5. Complete the BankDesktopController class
16.4.6. Register the BankDesktopController class as the Main class
16.5. Test the J2EE application client
16.6. Package the application client project
Chapter 17. Develop Web Services applications
17.1. Introduction to Web Services
17.1.1. Service-oriented architecture (SOA)
17.1.2. Web Services as an SOA implementation
17.1.3. Related Web Services standards
17.2. Web Services tools in Application Developer
17.2.1. Creating a Web Service from existing resources
17.2.2. Creating a skeleton Web Service
17.2.3. Client development
17.2.4. Testing tools for Web Services
17.3. Preparing for the samples
17.3.1. Import the sample code
17.3.2. Enable the Web Services Development capability
17.3.3. Set up the sample back-end database
17.3.4. Add Cloudscape JDBC driver (JAR) to the project
17.3.5. Define a server to test the application
17.3.6. Test the application
17.4. Create a Web Service from a JavaBean
17.4.1. Create a Web Service using the Web Service wizard
17.4.2. Resources generated by the Web Services wizard
17.4.3. Test the Web Service using the Web Services Explorer
17.4.4. Generate and test the client proxy
17.4.5. Monitor the Web Service using the TCP/IP Monitor
17.5. Create a Web Service from an EJB
17.6. Web Services security
17.7. Publish a Web Service using UDDI
Chapter 18. Develop portal applications
18.1. Introduction to portals
18.1.1. Portal concepts and definitions
18.1.2. IBM WebSphere Portal
18.1.3. IBM Rational Application Developer
18.2. Developing applications for WebSphere Portal
18.2.1. Portal samples and tutorials
18.2.2. Development strategy
18.2.3. Portal tools for developing portals
18.2.4. Portal tools for developing portlets
18.2.5. Portal tools for testing and debugging portlets
18.2.6. Portal tools for deploying and managing portlets
18.2.7. Enterprise Application Integration Portal Tools
18.2.8. Coexistence and migration of tools and applications
18.3. Portal development scenario
18.3.1. Prepare for the sample
18.3.2. Create a portal project
18.3.3. Add and modify a portal page
18.3.4. Create and modify two portlets
18.3.5. Add portlets to a portal page
18.3.6. Run the project in the test environment
Part 3. Test and debug applications
Chapter 19. Servers and server configuration
19.1. Introduction to server configuration
19.1.1. Supported test server environments
19.1.2. Local vs. remote test environments
19.1.3. Commands to manage test servers
19.2. Configure a WebSphere V6 Test Environment
19.2.1. Understanding WebSphere Application Server V6.0 profiles
19.2.2. WebSphere Application Server V6 installation
19.2.3. WebSphere Application Server V6 profile creation
19.2.4. Define a new server in Rational Application Developer
19.2.5. Verify the server
19.2.6. Customize a server in Rational Application Developer
19.3. Add a project to a server
19.3.1. Considerations for adding a project to a server
19.3.2. Add a project to a server
19.4. Remove a project from a server
19.4.1. Remove a project via Rational Application Developer
19.4.2. Remove a project via WebSphere Administrative Console
19.5. Publish application changes
19.6. Configure application and server resources
19.6.1. Configure application resources
19.6.2. Configure server resources
19.6.3. Configure messaging resources
19.6.4. Configure security
19.7. TCP/IP Monitor
Chapter 20. JUnit and component testing
20.1. Introduction to application testing
20.1.1. Test concepts
20.1.2. Benefits of unit and component testing
20.1.3. Eclipse Hyades
20.2. JUnit testing
20.2.1. JUnit fundamentals
20.2.2. Prepare for the sample
20.2.3. Create the JUnit test case
20.2.4. Run the JUnit test case
20.3. Automated component testing
20.3.1. Prepare for the sample
20.3.2. Create a test project
20.3.3. Create a Java component test
20.3.4. Complete the component test code
20.3.5. Run the component test
20.4. Web application testing
20.4.1. Preparing for the sample
20.4.2. Create a Java project
20.4.3. Create (record) a test
20.4.4. Edit the test
20.4.5. Generate an executable test
20.4.6. Create a deployment definition
20.4.7. Run the test
20.4.8. Analyze the test results
Chapter 21. Debug local and remote applications
21.1. Introduction to the debug tooling
21.1.1. Summary of new Version 6 features
21.1.2. Supported languages and environments
21.1.3. General functionality
21.1.4. Drop-to-frame
21.1.5. View Management
21.1.6. XSLT debugger
21.2. Prepare for the sample
21.3. Debug a Web application on a local server
21.3.1. Set breakpoints in a servlet
21.3.2. Set breakpoints in a JSP
21.3.3. Start the application for debugging
21.3.4. Run the application in the debugger
21.3.5. Debug view with stack frames
21.3.6. Debug functions
21.3.7. Breakpoints view
21.3.8. Watch variables
21.3.9. Inspect variables
21.3.10. Evaluate an expression
21.3.11. Debug a JSP
21.4. Debug a Web application on a remote server
21.4.1. Export the BankBasicWeb project to a WAR file
21.4.2. Deploy the BankBasicWeb.war
21.4.3. Install the IBM Rational Agent Controller
21.4.4. Configure debug on remote WebSphere Application Server
21.4.5. Attach to the remote server in Rational Application Developer
21.4.6. Debug the application on the remote server
Part 4. Deploy and profile applications
Chapter 22. Build applications with Ant
22.1. Introduction to Ant
22.1.1. Ant build files
22.1.2. Ant tasks
22.2. New features
22.2.1. Code Assist
22.2.2. Code snippets
22.2.3. Format an Ant script
22.2.4. Define format of an Ant script
22.2.5. Problem view
22.3. Build a simple Java application
22.3.1. Prepare for the sample
22.3.2. Create a build file
22.3.3. Project definition
22.3.4. Global properties
22.3.5. Build targets
22.3.6. Run Ant
22.3.7. Ant Log Console
22.3.8. Rerun Ant
22.3.9. Forced build
22.3.10. Classpath problem
22.3.11. Run the sample application to verify the Ant build
22.4. Build a J2EE application
22.4.1. J2EE application deployment packaging
22.4.2. Prepare for the sample
22.4.3. Create the build script
22.4.4. Run the Ant J2EE application build
22.5. Run Ant outside of Application Developer
22.5.1. Prepare for the headless build
22.5.2. Run the headless Ant build script
Chapter 23. Deploy enterprise applications
23.1. Introduction to application deployment
23.1.1. Common deployment considerations
23.1.2. J2EE application components and deployment modules
23.1.3. Java and WebSphere class loader
23.1.4. Deployment descriptors
23.1.5. WebSphere deployment architecture
23.2. Prepare for the sample
23.2.1. Review the deployment scenarios
23.2.2. Install prerequisite software
23.2.3. Import the sample application Project Interchange file
23.2.4. Set up the sample database
23.3. Package the application for deployment
23.3.1. Packaging recommendations
23.3.2. Generate the EJB to RDB mapping
23.3.3. Customize the deployment descriptors
23.3.4. Remove the Enhanced EAR datasource
23.3.5. Generate the deploy code
23.3.6. Export the EAR
23.4. Deploy the enterprise application
23.4.1. Configure the data source in WebSphere Application Server
23.4.2. Deploy the EAR
23.5. Verify the application
Chapter 24. Profile applications
24.1. Introduction to profiling
24.1.1. Profiling features
24.1.2. Profiling architecture
24.1.3. Profiling and Logging perspective
24.1.4. Profiling sets
24.2. Prepare for the profiling sample
24.2.1. Prerequisites hardware and software
24.2.2. Enable the Profiling and Logging capability
24.2.3. Import the sample project interchange file
24.2.4. Publish and run sample application
24.3. Profile the sample application
24.3.1. Start server in profile mode
24.3.2. Collect profile information
24.3.3. Analysis of code coverage information
Part 5. Team development
Chapter 25. Rational ClearCase integration
25.1. Introduction to IBM Rational ClearCase
25.1.1. IBM Rational Application Developer ClearCase overview
25.1.2. IBM Rational ClearCase terminology
25.1.3. IBM Rational ClearCase LT installation
25.1.4. IBM Rational Application Developer integration for ClearCase
25.2. Integration scenario overview
25.3. ClearCase setup for a new project
25.3.1. Enable Team capability in preferences
25.3.2. Create new ClearCase project
25.3.3. Join a ClearCase project
25.3.4. Create a Web project
25.3.5. Add a project to ClearCase source control
25.4. Development scenario
25.4.1. Developer 1 adds a servlet
25.4.2. Developer 1 delivers work to the integration stream
25.4.3. Developer 1 makes a baseline
25.4.4. Developer 2 joins the project
25.4.5. Developer 2 imports projects into Application Developer
25.4.6. Developer 2 modifies the servlet
25.4.7. Developer 2 delivers work to the integration stream
25.4.8. Developer 1 modifies the servlet
25.4.9. Developer 1 delivers new work to the integration stream
Chapter 26. CVS integration
26.1. Introduction to CVS
26.1.1. CVS features
26.1.2. New V6 features for team development
26.2. CVSNT Server implementation
26.2.1. CVS Server installation
26.2.2. CVS Server repository configuration
26.2.3. Create the Windows users and groups used by CVS
26.2.4. Verify the CVSNT installation
26.2.5. Create CVS users
26.3. CVS client configuration for Application Developer
26.3.1. Configure CVS Team Capabilities
26.3.2. Access the CVS Repository
26.4. Configure CVS in Rational Application Developer
26.4.1. Configure Rational Application Developer CVS preferences
26.5. Development scenario
26.5.1. Create and share the project (step 1 - cvsuser1)
26.5.2. Add a shared project to the workspace (step 2 - cvsuser2)
26.5.3. Modifying the Servlet (step 2 - cvsuser1)
26.5.4. Synchronize with repository (step 3 - cvsuser1)
26.5.5. Parallel development (step 4 - cvsuser1 and cvsuser2)
26.5.6. Versioning (step 5- cvsuser1)
26.6. CVS resource history
26.7. Comparisons in CVS
26.7.1. Comparing workspace file with repository
26.7.2. Comparing two revisions in repository
26.8. Annotations in CVS
26.9. Branches in CVS
26.9.1. Branching
26.9.2. Merging
26.9.3. Refreshing server-defined branches
26.10. Work with patches
26.11. Disconnecting a project
26.12. Synchronize perspective
26.12.1. Custom configuration of resource synchronization
26.12.2. Schedule synchronization
Part 6. Appendixes