SEARCH
Disclaimer: Authors have full rights over their works. Reproduction of any part of the content is prohibited without prior authorization.
BOOK ORACLE ADF ENTERPRISE APPLICATION DEVELOPMENT MADE SIMPLE 2ND EDITION
SUMMARY
-
Items Found: 462
- Preface 1
- Chapter 1: The ADF Proof of Concept 11
- Understanding the architecture of ADF 12
- Enterprise architecture 12
- The frontend part 12
- The backend part 13
- The ADF architecture 13
- Entity objects and associations 15
- View objects and view links 15
- Application modules 16
- The ADF user interface 17
- ADF Task Flows 18
- ADF pages and fragments 18
- The Proof of Concept 19
- Content of a Proof of Concept 19
- Making the technology work 20
- Determining the development speed 21
- The Proof of Concept deliverables 22
- The Proof of Concept case study 23
- Use cases 24
- UC008 Task Overview and Edit 24
- UC104 Person Task Timeline 25
- Data model 25
- Getting started with JDeveloper 27
- The JDeveloper window and panels 29
- Setting JDeveloper preferences 29
- The Proof of Concept ADF Business Components 31
- Creating a connection 31
- Entity objects for the Proof of Concept 33
- Building associations for the Proof of Concept 35
- Building view objects and view links for the Proof of Concept 36
- Creating view objects for value lists 36
- Creating a view object for tasks 38
- Building an application module for tasks 41
- Creating view objects for scheduling 43
- Building an application module for scheduling 45
- The Proof of Concept ADF user interface 47
- ADF Task Flows 48
- The tasks page 49
- Creating the tasks page 49
- Running the initial tasks page 54
- Refining the tasks page 54
- Fixing the bindings 59
- Running the tasks page with parameters 60
- Adding database operations 61
- Running the tasks page with database operations 63
- The scheduled tasks page 63
- Adding the Gantt component 64
- Navigation 65
- Summary 67
- Chapter 2: Estimating the Effort 69
- Gathering requirements 69
- Building it just like the old system 70
- Use cases 70
- User stories 73
- Non-functional requirements 73
- Requirement lists 74
- Screen design 74
- Deciding how to build it 76
- Deciding how much to build at a time 76
- Deciding how much to build yourself 77
- Deciding how to integrate 77
- Application architecture 78
- Example Work Breakdown Structure 80
- Estimating the solution 83
- Top-down estimate 83
- Bottom-up estimate 83
- Three-point estimates 84
- Grouping – simple, normal, and hard 85
- More input, better estimates 86
- Adding it all up – the final estimate 88
- Swings and roundabouts 88
- Calculating the standard deviation for a task 89
- Calculating the standard deviation for a project 89
- Sanity check 90
- From effort to calendar time 91
- Summary 91
- Chapter 3: Getting Organized 93
- Skills required for an ADF project 93
- ADF framework knowledge 94
- Object-oriented programming 95
- Java programming 95
- Database design and programming 96
- XML knowledge 96
- Web technologies 97
- Regular expressions 97
- Graphics design 98
- Usability 99
- Testing 99
- Organizing the team 99
- Project manager 100
- Software architect and lead programmer 100
- Regular programmers 101
- Building Business Components 102
- Building the user interface 102
- Skinning 103
- Templates 103
- Defining data validation 104
- Building support classes 104
- Building database stored procedures 105
- Build/configuration manager 105
- Database and application server administrator 106
- Graphic designers 107
- Usability experts 107
- Quality assurance, test manager, and tester 108
- Data modelers 108
- Users 109
- Gathering the tools 109
- Source control 110
- Bug/issue tracking 111
- Collaboration 112
- Shared documents 112
- Discussion forums 113
- Online chat 113
- Test and requirement management 114
- Automated build system 114
- Structuring workspaces, projects, and code 115
- Using projects 115
- Simple architecture 115
- Modular architecture 116
- Application Common Workspace 117
- Database workspace 119
- Subsystem workspaces 119
- Master workspace 119
- Enterprise architecture 120
- Enterprise Common Workspace 120
- Master application workspaces 120
- Naming conventions 121
- General 121
- Java packages 121
- Project code 121
- Enterprise Common Code 122
- Database objects 123
- ADF elements 124
- File locations 125
- Test code 126
- Summary 127
- Chapter 4: Productive Teamwork 129
- The secret of productivity 129
- More pixels give better productivity 129
- Version control 130
- Avoiding spreadsheets 130
- Split your project into tasks 130
- Focus 130
- Integrate your tools 131
- Version control with Subversion 131
- Effective Subversion 132
- Handling new files 133
- Starting with Subversion 134
- Working with Subversion 135
- Getting a new copy 136
- Getting other peoples changes 137
- Automatic merge 137
- Handling conflicts 138
- Version control with Git 140
- Effective Git 140
- Staging and committing 141
- Preparing your local repository 142
- Initial load of a workspace 146
- Working with Git 147
- Starting the day 148
- Starting work on a task 148
- Committing often to a task 148
- Completing a task 149
- Ending the day 149
- Handling conflicts 150
- Avoiding conflicts 151
- Focusing for maximum productivity 152
- The Integrated Solution – Oracle Team Productivity Center 154
- Installing the server 155
- Connecting JDeveloper to repositories 157
- Administration tasks 158
- Working with Oracle Team Productivity Center 158
- Working with work items 159
- Finding work items 159
- Setting the active work item 159
- Linking work items 160
- Tagging work items 160
- Saving and restoring context 160
- Code reviews 161
- Viewing build status 162
- Chat 162
- Reading news 162
- Summary 162
- Chapter 5: Preparing to Build 163
- Creating common workspaces 163
- Working with task flow templates 165
- Creating a task flow template 166
- Contents of your task flow template 167
- An exception handler 167
- Initializers and finalizers 169
- Creating several levels of templates 169
- Working with page templates 169
- Creating a page template 170
- Using layout containers 172
- Working with facets 173
- Defining template facets 173
- Understanding component facets 174
- Defining template attributes 175
- Adding content to the page template 175
- Framework extension classes 176
- Understanding how Java classes are used in ADF 177
- Some Java required 178
- The place for framework extension classes 178
- Creating framework extension classes 180
- Using framework extension classes 182
- Packaging your common code 183
- Summary 184
- Chapter 6: Building the Enterprise Application 185
- Structuring your code 185
- Using workspaces 186
- The workspace hierarchy 186
- Creating a workspace 187
- Working with ADF Libraries 188
- The ADF Library workflow 188
- Using ADF Libraries 189
- Building the Common Model 190
- Use framework extension classes 190
- Entity objects 190
- Primary key generation 193
- Business rules 193
- User interface strings 194
- Common View objects 194
- Testing the Common Model 196
- Exporting an ADF Library 196
- Organizing the work 198
- Preconditions 198
- Development tasks 199
- Creating Business Components 199
- Building view objects, view links, and the application module 199
- Implementing Business Logic 201
- Testing your Business Components 201
- Creating task flows 201
- Reviewing the task flows 202
- Creating the page fragments 203
- Implementing UI logic 203
- Defining the UI test 203
- Reviewing the UI test 204
- Implementing the task management subsystem 204
- Setting up a new workspace 204
- Getting the libraries 205
- Creating Business Components 206
- Starting work 207
- Building the main view object 207
- Building the application module 210
- Testing your Business Components 210
- Checking in your code 210
- Finishing the tasks 212
- Creating the task flow 212
- Creating the page fragment 213
- Data table 214
- Search panel 215
- Fixing the bindings 216
- Running the page 217
- OK and Cancel buttons 218
- Checking in your code 218
- Deploying the task management subsystem 220
- Implementing the scheduling subsystem 221
- Setting up a new workspace 221
- Getting the libraries 221
- Creating Business Components 222
- Building the persons view object 222
- Building the tasks view object 223
- Building the master-detail link 223
- Building the MinMaxDate view object 223
- Building the application module 225
- Testing your Business Components 226
- Finishing the tasks 226
- Building the task flow 226
- Building the page 227
- Adding a Gantt chart component 227
- Defining the start and end time 229
- Running the page 230
- Checking in your code 231
- Deploying your scheduling subsystem 231
- Building the master application 231
- Setting up the master workspace 232
- Getting the libraries 232
- Creating the master page 233
- Creating the layout 234
- Adding the menu 234
- Creating a dynamic region 234
- Understanding the dynamic region 236
- Additional code for task flow switching 237
- Storing the selected task flow value 237
- Accessing the session bean from the backing bean 238
- Setting up the task flow values 239
- Making the region redraw itself 240
- Checking in your code 241
- Summary 242
- Chapter 7: Testing Your Application 243
- Initial tests 243
- Working with JUnit 244
- Using JUnit to test code 245
- Writing good unit tests 245
- The unit testing ADF applications 246
- Preparing for unit testing 246
- Setting up a test project 247
- Adding default testing 248
- The real unit testing example 253
- Adding a test case 253
- Implementing logical delete 256
- Re-testing 258
- Automating unit testing 258
- User interface tests 258
- What should you test? 258
- About Selenium 259
- Installing Selenium IDE 260
- A simple test with Selenium 260
- Exporting your test 265
- Using Selenium effectively 266
- Value checking options 266
- Lazy content delivery 266
- Testing the context menus 267
- Verifying the item ID 267
- Testing passivation and activation 267
- Stress and performance tests 269
- Working with JMeter 269
- Testing application performance with JMeter 270
- Installing and running JMeter 270
- A simple test with JMeter 271
- Setting up JMeter as a proxy 272
- Recording a session 274
- Post-processing a recorded session 274
- Running a recorded session 275
- Troubleshooting JMeter sessions 276
- The Oracle alternative 277
- Summary 277
- Chapter 8: Changing the Appearance 279
- Controlling appearance 279
- The Cascading Style Sheets basics 280
- Styling individual components 281
- Building a style 282
- InlineStyle and ContentStyle 283
- Unravelling the mysteries of CSS styling 285
- Conditional formatting 289
- Skinning overview 289
- Skinning capabilities 289
- Skinning recommendations 293
- The skinning process 293
- Creating a skin project 294
- Skinning in practice 294
- Creating a skin CSS file 295
- Working in the Design tab 297
- Working in the Selectors tab 298
- Style Classes 299
- Global Selector Aliases 299
- At-Rules 299
- Faces Component Selectors 299
- Data Visualizations Component Selectors 301
- Finding the selector at runtime 301
- Optionally providing images for your skin 302
- Optionally creating a resource bundle for your skin 303
- Packaging the skin 305
- Using the skin 305
- Summary 306
- Chapter 9: Customizing Functionality 307
- The reason for customization 307
- The technology behind ADF customization 308
- Applying customization layers 309
- Making an application customizable 311
- Developing customization classes 311
- Building the classes 311
- Implementing the methods 313
- Deploying the customization classes 314
- Enabling seeded customization 315
- Linking the customization class to the application 316
- Configuring customization layers 317
- Using resource bundles 319
- Allowing resource bundle customization 321
- Performing customization 321
- Selecting the customization role 322
- Customizing Business Components 323
- Customizing pages 324
- Customizing strings 326
- Elements that cannot be customized 328
- Summary 329
- Chapter 10: Securing Your ADF Application 331
- The security basics 331
- Authentication means knowing your user 332
- Authorization means deciding on access 332
- The Oracle security solution 333
- Alternative security 333
- Security decisions 333
- Performing authentication 334
- Performing authorization 334
- Where to implement security 334
- Implementing ADF Security 334
- Selecting a security model 335
- Selecting the authentication type 336
- Selecting how to grant access 337
- Select a common welcome page 338
- Application roles 339
- Implementing the user interface security 340
- Securing task flows 340
- Securing pages 341
- Using entitlements 341
- Implementing data security 341
- Defining protected operations 342
- Protecting an entity object 342
- Protecting an attribute 343
- Granting operations to roles 343
- Users and groups 344
- Mapping the application to the organization 344
- Example users and enterprise roles 345
- Assigning application roles 347
- Running the application 348
- Removing inaccessible items 348
- Summary 349
- Chapter 11: Packaging and Delivery 351
- The contents of a good deployment package 351
- The runnable application 352
- Database code 352
- Installation and operation instructions 352
- Preparing for deployment 353
- Cleaning up your code 353
- Test users and groups 354
- Other development artifacts 355
- Performing code audit 356
- Ignoring rules 357
- Checking more rules 357
- Setting application parameters for production use 357
- Application module tuning 358
- Controlling database locking 359
- Tuning your ADF application 360
- Setting up the application server 361
- Number of servers 361
- Installing WebLogic 12c standalone for ADF 362
- Creating a data source on the server 362
- Deploying the application 366
- Direct deployment 366
- Creating an application server connection 366
- Deploying your application directly 368
- Deploying the file through the console 370
- Creating the EAR file 370
- Deploying the EAR file 371
- Scripting the build process 373
- Creating a build task 373
- Creating a build task for the master project 373
- Creating build tasks for ADF Libraries 375
- Creating a build task for the master application 376
- Moving your task to the test/integration server 376
- Adding a checkout 376
- Adding the database 377
- More scripting 377
- Automation 377
- Summary 378
- Appendix: Internationalization 379
- Automatic internationalization 380
- How localizable strings are stored 382
- Defining localizable strings 385
- Performing the translation 387
- Running your localized application 389
- Testing the localized Business Components 389
- Testing the localized user interface 389
- Localizing formats 391
- More internationalization 391
- Summary 392
- Index 393
- Preface
- Welcome to your first real-life enterprise ADF application!
- The book you are holding in your hands is about building seriou
