JSP (Java Server Pages) Lecture # 9
Java Server Faces the best Alternative of C# and Easy to make your own Application (Desktop applications) or web applications
The document discusses JavaServer Faces (JSF), an MVC framework for building web interfaces. It provides:
- An overview of JSF concepts like managed beans, expression language, navigation rules, and components.
- Examples of using JSF for static and dynamic navigation between pages, including declaring beans and navigation rules in faces-config.xml.
- How JSF handles form submission and uses managed beans to represent request parameters and output data to results pages.
This document provides an overview of JavaServer Faces (JSF), including:
1. JSF is a server-side user interface framework that provides reusable UI components, event handling, validation and integration with backend data for Java web applications.
2. The document outlines key JSF concepts like UI components, events, validators, converters and renderers. It also describes the request processing lifecycle and developer roles.
3. Advanced topics like navigation, internationalization and custom components are listed for discussion in a later session.
This document provides an overview of JavaServer Faces (JSF), including:
- An introduction to JSF and what it is
- A description of the JSF request lifecycle and faces servlet
- An explanation of JSF component models and commonly used tags
- A step-by-step guide for creating a basic "Hello World" JSF application
- Details about JSP architectures (Model 1 and Model 2) that provide context for JSF
JSF 2 life cycle consists of 6 phases: restore view, apply request values, process validations, update model values, invoke application, and render response. Managed beans are JavaBeans that can be accessed from JSF pages and are used to store data. Facelets is the templating language used by JSF 2 that replaced JSP. Navigation between pages can be done through configuration, implicit navigation based on action outcomes, or redirection. New features in JSF 2.2 include faces flows for page flows, HTML5 support, and a file upload component.
Java Server Faces is a framework for building user interfaces for web applications that provides ease-of-use, standardization, and device independence through reusable UI components, easy data transfer between components, custom component implementation, and UI state management across requests. It is intended for use by developers, page authors, application developers, component writers, and tools vendors.
This document introduces Java Server Faces (JSF), a server-side user interface framework. It discusses JSF's architecture, which follows the MVC pattern. The UI component model in JSF includes components, events, validators, converters, and navigation support. Developing a JSF application involves creating managed beans, defining pages with JSF tags, configuring navigation in faces-config.xml, and setting up the web.xml file. JSF applications use a request processing lifecycle to handle requests and render responses.
Java Server Faces (JSF) is a Java web development framework that provides reusable UI components and a component-based MVC architecture. Key aspects of JSF include:
- Clean separation of behavior and presentation using a component-based MVC model.
- Standard UI components and events tied to server-side code.
- Typical JSF applications include JavaBeans for state/behavior, event-driven development, and JSP view pages that reference a component tree.
The example JSF calculator application demonstrates:
1) Configuring the Faces servlet and managed beans.
2) Developing a model class and controller to mediate between the view and model.
3) Creating
Starting with Spring MVC 2.5, Annotation-Based Controllers became the preferred model for development (the Interface-based Controller hierarchy will be deprecated in Spring 3). This session will teach developers familiar with the old model how to use the new Annotation-based Controllers. This will also provide the basis for writing JSR 286 portlets using Spring 3.
Sample code available here:
http://www.ja-sig.org/wiki/x/vYS8AQ
Full screencast available here:
http://vimeo.com/10020881
This document provides a summary of the major new features in JavaServer Faces (JSF) 2.0, including Facelets as the preferred view declaration language, composite components, Ajax support, partial state saving, view parameters, system events, resources, behaviors, view traversal, annotations, navigation, exceptions, validation, EL improvements, and new scopes. It highlights contributions from the JSF expert group and community and provides resources for learning more about JSF 2.0.
Java Server Faces + Spring MVC FrameworkGuo Albert
This document discusses the architecture of a Java Server Faces application integrated with the Spring MVC framework. It describes the presentation and business tiers, including the front controller, UI components, backing beans, views, service beans, and configuration files like web.xml, faces-config.xml, and applicationContext.xml. It also includes class diagrams and details the page flow and configuration of the demo application.
This document provides an overview of JavaServer Faces (JSF), including its architecture, components, lifecycle, and usage. JSF is a component-based user interface framework for building web applications using reusable UI components and a component-oriented approach. The key aspects covered include the MVC architecture of JSF with models, views, and controllers; the main JSF components and their roles; the request processing lifecycle; and best practices for code implementation.
This session will provide a complete tour of using the Spring MVC framework to build Java Portlets. It will include an in-depth review of a sample portlet application developed using the latest features of Spring MVC, including Annotation-based Controllers. If you are writing Portlets and using Spring, this session is for you.
We'll begin by discussing the unique differences and challenges when developing Portlets instead of traditional Servlet webapps. Then we'll talk about the unique approach that Spring MVC takes towards Portlets that fully leverages the Portlet lifecycle, instead of masking it like many other frameworks. We'll take an extensive tour of a sample application so we can see all the unique pieces of the framework in action. Finally we'll conclude with discussion of the upcoming support for the Portlet 2.0 (JSR 286) specification that will be part of Spring 3.0.
This presentation will explain about spring and hibernate integration based on Java config. moreover, this presentation has a detailed explanation of spring and hibernate integration.
This document provides an overview of the Struts framework and its key components. It covers the model-view-controller design pattern used in Struts, the model components including JavaBeans and ActionForm beans, view components like JSP tags and internationalization, controller components like Action classes and the configuration file, and finally the tag libraries used in Struts. The document is part of a training course on Struts and introduces each major concept across 9 units.
Java Server Faces (JSF) is a component-based MVC framework for building user interfaces in Java web applications. JSF provides UI components that can be used in JSP or Facelets views. It follows a request response lifecycle where the controller handles gathering input, validating, updating models, and rendering responses. Popular JSF components include inputs, outputs, selects, forms, and commands. Facelets is the default view technology in JSF 2 and provides templating capabilities. Key differences between JSF and JSF 2 include replacing JSP with Facelets and adding Ajax and annotation support. Spring MVC has the highest demand and documentation quality while Struts 2 has the lowest learning curve and JSF is in
JSF is a Java specification and framework for building component-based user interfaces for web applications. It uses the MVC design pattern with reusable UI components, and handles tasks like data conversion, validation, event handling and navigation. The JSF architecture includes a component tree, request processing lifecycle and rendering model. New features in JSF 2 include Facelets as the default view declaration language, annotation-based configuration, standardized Ajax support, and improved error handling. Developing with JSF involves creating managed bean models, registering them, building pages with UI components, defining navigation, and configuring the web application in web.xml.
This document provides an overview of Java Server Pages (JSP) technology. Some key points:
- JSP allows separation of work between web designers and developers by allowing HTML/CSS design and Java code to be placed in the same file.
- A JSP page is compiled into a servlet, so it can take advantage of servlet features like platform independence and database-driven applications.
- JSP pages use tags like <jsp:include> and <jsp:useBean> to include content and access JavaBeans. Scriptlets, expressions, declarations, and directives are also used.
- Implicit objects like request, response, out, and session are automatically available in JSP pages
The Spring MVC framework uses the model-view-controller (MVC) architecture. It features a DispatcherServlet that handles requests and responses and relies on controllers to process user input and build the model data before passing it to the view for rendering. Configuration involves mapping the DispatcherServlet to URLs in web.xml and defining controllers with annotations and handler methods. Spring Security integrates with Spring MVC to add authentication and authorization for specific URLs specified in the spring-security.xml configuration file.
The document discusses the history and architecture of JSF component behaviors. It describes how behaviors allow adding functionality to components through attached objects. A behavior API was introduced to provide a loose coupling between components and behaviors. The API uses client behaviors and behavior holders. The document demonstrates a simple confirm behavior and more advanced auto-suggest behavior to showcase the capabilities of the behavior API.
The Spring Framework provides a comprehensive Java platform for developing applications. It simplifies development by allowing developers to avoid dealing directly with complex APIs. Spring uses Inversion of Control and Dependency Injection to decouple classes and increase maintainability. The core Spring modules include beans, context, AOP, and aspects. Spring MVC implements the MVC pattern to build web applications, separating the model, view, and controller aspects.
University of Colorado PhD software engineering student Aaron Schram explains the details of creating a web applications using the Spring MVC framework
JSF 2 and beyond: Keeping progress comingAndy Schwartz
Covers new features in JSF 2, community involvement in JSF and a look towards the future of this framework.
Presented by Dan Allen, Pete Muir and Andy Schwartz at Devoxx 2009.
http://www.devoxx.com/display/DV09/JSF+2+and+beyond
Spring MVC 3.0 Framework
Objective:
1. Introduce Spring MVC Module
2. Learn about Spring MVC Components (Dispatcher, Handler mapping, Controller, View Resolver, View)
Slides:
1. What Is Spring?
2. Why use Spring?
3. By the way, just what is MVC?
4. MVC Architecture
5. Spring MVC Architecture
7. Spring MVC Components
8. DispatcherServlet
9. DispatcherServlet Architecture.........
.........................................................
This document provides an introduction and overview of JavaScript. It discusses that JavaScript is a client-side scripting language that can be inserted into HTML pages and run by web browsers to provide interactive and dynamic features. It covers JavaScript basics like data types, variables, operators, functions, and events. It also explains how to write JavaScript code directly in HTML pages or externally and shows examples of built-in functions and how to create user-defined functions.
This document discusses DHTML and CSS. It defines DHTML as a combination of HTML, CSS, and scripting that allows dynamic web pages. It describes the four main components of DHTML - HTML, CSS, scripting languages like JavaScript, and the DOM. It provides details on each component, including how CSS controls formatting, how scripting adds interactivity, and how the DOM defines elements for script access. It also gives examples of using internal, inline, and external CSS stylesheets.
This document provides a summary of the major new features in JavaServer Faces (JSF) 2.0, including Facelets as the preferred view declaration language, composite components, Ajax support, partial state saving, view parameters, system events, resources, behaviors, view traversal, annotations, navigation, exceptions, validation, EL improvements, and new scopes. It highlights contributions from the JSF expert group and community and provides resources for learning more about JSF 2.0.
Java Server Faces + Spring MVC FrameworkGuo Albert
This document discusses the architecture of a Java Server Faces application integrated with the Spring MVC framework. It describes the presentation and business tiers, including the front controller, UI components, backing beans, views, service beans, and configuration files like web.xml, faces-config.xml, and applicationContext.xml. It also includes class diagrams and details the page flow and configuration of the demo application.
This document provides an overview of JavaServer Faces (JSF), including its architecture, components, lifecycle, and usage. JSF is a component-based user interface framework for building web applications using reusable UI components and a component-oriented approach. The key aspects covered include the MVC architecture of JSF with models, views, and controllers; the main JSF components and their roles; the request processing lifecycle; and best practices for code implementation.
This session will provide a complete tour of using the Spring MVC framework to build Java Portlets. It will include an in-depth review of a sample portlet application developed using the latest features of Spring MVC, including Annotation-based Controllers. If you are writing Portlets and using Spring, this session is for you.
We'll begin by discussing the unique differences and challenges when developing Portlets instead of traditional Servlet webapps. Then we'll talk about the unique approach that Spring MVC takes towards Portlets that fully leverages the Portlet lifecycle, instead of masking it like many other frameworks. We'll take an extensive tour of a sample application so we can see all the unique pieces of the framework in action. Finally we'll conclude with discussion of the upcoming support for the Portlet 2.0 (JSR 286) specification that will be part of Spring 3.0.
This presentation will explain about spring and hibernate integration based on Java config. moreover, this presentation has a detailed explanation of spring and hibernate integration.
This document provides an overview of the Struts framework and its key components. It covers the model-view-controller design pattern used in Struts, the model components including JavaBeans and ActionForm beans, view components like JSP tags and internationalization, controller components like Action classes and the configuration file, and finally the tag libraries used in Struts. The document is part of a training course on Struts and introduces each major concept across 9 units.
Java Server Faces (JSF) is a component-based MVC framework for building user interfaces in Java web applications. JSF provides UI components that can be used in JSP or Facelets views. It follows a request response lifecycle where the controller handles gathering input, validating, updating models, and rendering responses. Popular JSF components include inputs, outputs, selects, forms, and commands. Facelets is the default view technology in JSF 2 and provides templating capabilities. Key differences between JSF and JSF 2 include replacing JSP with Facelets and adding Ajax and annotation support. Spring MVC has the highest demand and documentation quality while Struts 2 has the lowest learning curve and JSF is in
JSF is a Java specification and framework for building component-based user interfaces for web applications. It uses the MVC design pattern with reusable UI components, and handles tasks like data conversion, validation, event handling and navigation. The JSF architecture includes a component tree, request processing lifecycle and rendering model. New features in JSF 2 include Facelets as the default view declaration language, annotation-based configuration, standardized Ajax support, and improved error handling. Developing with JSF involves creating managed bean models, registering them, building pages with UI components, defining navigation, and configuring the web application in web.xml.
This document provides an overview of Java Server Pages (JSP) technology. Some key points:
- JSP allows separation of work between web designers and developers by allowing HTML/CSS design and Java code to be placed in the same file.
- A JSP page is compiled into a servlet, so it can take advantage of servlet features like platform independence and database-driven applications.
- JSP pages use tags like <jsp:include> and <jsp:useBean> to include content and access JavaBeans. Scriptlets, expressions, declarations, and directives are also used.
- Implicit objects like request, response, out, and session are automatically available in JSP pages
The Spring MVC framework uses the model-view-controller (MVC) architecture. It features a DispatcherServlet that handles requests and responses and relies on controllers to process user input and build the model data before passing it to the view for rendering. Configuration involves mapping the DispatcherServlet to URLs in web.xml and defining controllers with annotations and handler methods. Spring Security integrates with Spring MVC to add authentication and authorization for specific URLs specified in the spring-security.xml configuration file.
The document discusses the history and architecture of JSF component behaviors. It describes how behaviors allow adding functionality to components through attached objects. A behavior API was introduced to provide a loose coupling between components and behaviors. The API uses client behaviors and behavior holders. The document demonstrates a simple confirm behavior and more advanced auto-suggest behavior to showcase the capabilities of the behavior API.
The Spring Framework provides a comprehensive Java platform for developing applications. It simplifies development by allowing developers to avoid dealing directly with complex APIs. Spring uses Inversion of Control and Dependency Injection to decouple classes and increase maintainability. The core Spring modules include beans, context, AOP, and aspects. Spring MVC implements the MVC pattern to build web applications, separating the model, view, and controller aspects.
University of Colorado PhD software engineering student Aaron Schram explains the details of creating a web applications using the Spring MVC framework
JSF 2 and beyond: Keeping progress comingAndy Schwartz
Covers new features in JSF 2, community involvement in JSF and a look towards the future of this framework.
Presented by Dan Allen, Pete Muir and Andy Schwartz at Devoxx 2009.
http://www.devoxx.com/display/DV09/JSF+2+and+beyond
Spring MVC 3.0 Framework
Objective:
1. Introduce Spring MVC Module
2. Learn about Spring MVC Components (Dispatcher, Handler mapping, Controller, View Resolver, View)
Slides:
1. What Is Spring?
2. Why use Spring?
3. By the way, just what is MVC?
4. MVC Architecture
5. Spring MVC Architecture
7. Spring MVC Components
8. DispatcherServlet
9. DispatcherServlet Architecture.........
.........................................................
This document provides an introduction and overview of JavaScript. It discusses that JavaScript is a client-side scripting language that can be inserted into HTML pages and run by web browsers to provide interactive and dynamic features. It covers JavaScript basics like data types, variables, operators, functions, and events. It also explains how to write JavaScript code directly in HTML pages or externally and shows examples of built-in functions and how to create user-defined functions.
This document discusses DHTML and CSS. It defines DHTML as a combination of HTML, CSS, and scripting that allows dynamic web pages. It describes the four main components of DHTML - HTML, CSS, scripting languages like JavaScript, and the DOM. It provides details on each component, including how CSS controls formatting, how scripting adds interactivity, and how the DOM defines elements for script access. It also gives examples of using internal, inline, and external CSS stylesheets.
A web server is software that responds to requests from web browsers to serve web pages. It is part of a multi-tier architecture with an information tier (database), middle tier (application logic), and client tier (user interface). The most common protocol for communication between clients and servers is HTTP, with the server responding to GET and POST requests with web pages or other responses. Popular web server software includes Apache, IIS, and Tomcat.
This document provides an overview of data warehousing, OLAP, data mining, and big data. It discusses how data warehouses integrate data from different sources to create a consistent view for analysis. OLAP enables interactive analysis of aggregated data through multidimensional views and calculations. Data mining finds hidden patterns in large datasets through techniques like predictive modeling, segmentation, link analysis and deviation detection. The document provides examples of how these technologies are used in industries like retail, banking and insurance.
Ruby on Rails is a web application framework written in Ruby. It was created in 2004 by David Heinemeier Hansson and has since become one of the most popular frameworks for web development. Rails emphasizes convention over configuration, following agile programming principles, and aims to make web development simpler and more enjoyable. The core components of a Rails application include models, views, controllers, helpers and initializers organized into folders that follow standard conventions.
Ruby on Rails is a popular web application framework written in Ruby. It follows the model-view-controller (MVC) pattern and includes components like Action Pack, Active Support, Active Record, and Action Mailer. The document provides an overview of Rails, Ruby basics, installing Rails, the directory structure of a Rails application, and the MVC pattern.
Introduction to Ruby and Introduction to Ruby on Rails basic concepts for beginners. The google presentation is even better in full screen https://docs.google.com/presentation/d/1EE0VuB_PkD2-8j5JNs6CUQHb4J9ToIgC7-IxYTojiS0/pub?start=false&loop=false&delayms=3000#slide=id.p
The JavaScript programming language is a multi-paradigm language that is misunderstood due to its name, design errors in early implementations, and use in web browsers. It is a functional language that uses objects, prototypes, and closures. Values in JavaScript include numbers, strings, Booleans, objects, null, and undefined. All other values are objects.
Functions being first-class citizens in JavaScript offers developers a tremendous amount power and
flexibilty. However, what good is all this power if you don't know how to harness it?
This talk will provide a thorough examination of JavaScript functions. Topics
that will be covered in this talk are:
* Functions are objects
* Execution Context and the Scope Chain
* Closures
* Modifying Context
* The Various Forms of Functions.
Attendees will leave this talk understanding the power of JavaScript functions and the knowledge to apply new
techiques that will make their JavaScript cleaner, leaner and more maintainable.
AJAX allows web pages to be updated asynchronously by exchanging data with a web server behind the scenes without reloading the entire page. It uses a combination of technologies including XMLHttpRequest objects, JavaScript, DOM, and CSS. The XMLHttpRequest object sends and receives data from the server that can be used to update portions of a web page. This improves interactivity and allows for dynamic interfaces.
The document discusses web servers and their key components and functions. It covers:
1) The definition of a web server as a program that generates and transmits responses to client requests for web resources by parsing requests, authorizing access, and constructing responses.
2) How web servers handle client requests through steps like parsing requests, authorizing access, and transmitting responses. They can also dynamically generate responses through server-side includes and server scripts.
3) Techniques web servers use like access control through authentication and authorization, passing data to scripts, using cookies, caching responses, and allocating resources through event-driven, process-driven, and hybrid architectures.
This document provides an overview of JavaServer Faces (JSF), a Java framework for building user interfaces for web applications. It discusses that JSF is a standard created by Java Community Process to make client-side development browser-independent and include features like state management. It also describes key characteristics of JSF like being server-side, using a component framework, and supporting features like validation and error handling. The document outlines the JSF application lifecycle process and how JSF uses managed backing beans to hold user-entered data. It provides examples of converting a JSP to a JSF page and the JSF navigation model.
This document provides an overview of JavaServer Faces (JSF), a Java framework for building user interfaces for web applications. It discusses that JSF is a standard Java framework created as a Java Community Process to make client-side development browser-independent and include features like state management. It also summarizes that JSF uses a model-view-controller approach with UI components on the server-side, has a defined programming model and tag libraries, and helps with reusability and easier event handling and separation of behavior and presentation. Finally, it provides examples of converting a JSP to a JSF page and using managed beans and navigation in JSF applications.
JavaServer Faces (JSF) is a web application framework that uses the model-view-controller (MVC) paradigm. It provides reusable UI components and manages the flow of web applications. MyFaces is an open source implementation of JSF that provides additional pre-built components. The document discusses the JSF architecture, how it works, example code components like input fields and validators, and advantages like reusable components and built-in validation.
The document provides an overview of JavaServer Faces (JSF) including:
- Key JSF concepts like page navigation, managed beans, expression language, and event handling.
- How to implement static and dynamic navigation between pages using navigation rules defined in faces-config.xml.
- An example of dynamic navigation that collects user information, invokes a controller method on submit, and conditionally navigates to an acceptance or rejection page.
Java Server Faces (JSF) is a Java web application framework that uses the model-view-controller (MVC) architectural pattern. JSF has a component-based user interface that separates UI components from business logic. It provides features like data binding, validation, internationalization and AJAX. JSF applications typically consist of JavaBeans components, JSP pages that represent views, and configuration files that define workflows between pages.
The document discusses the Yii PHP framework. It provides an overview of Yii's fundamentals including its use of the MVC pattern, entry scripts, debug mode, applications, controllers, actions, filters, models, views, layouts, and widgets. It also summarizes how to create a basic Yii application, the code generation tools, and some key features such as database access, forms/validation, authentication, caching, and automatic code generation.
The document outlines the content covered in an Oracle ADF online training course, including 18 topics that range from introductions to ADF and JDeveloper, building data and user interfaces, ensuring reusability, implementing transactions and security, and deploying ADF applications. Key aspects covered include creating ADF business components and view objects, binding UI components to data, planning task flows and navigation, and deploying applications using JDeveloper or WebLogic Server.
This document describes building a bridge between JADE agent applications and web frontends using JavaServer Faces (JSF) technology. It connects a JSF web application to a proxy agent in JADE. The proxy agent handles user requests by retrieving agent information from the JADE Directory Facilitator and updating the JSF user interface. Business objects like AgentInfo are used to share data between the JSF application and JADE agents. The proxy agent has a cyclic behavior that processes incoming requests by launching one-shot behaviors to interface with the Directory Facilitator and notify the JSF application.
The document summarizes several key Java EE services including resource management, Java Naming and Directory Service (JNDS), security services, and transaction services. Resource management is implemented using resource pooling and activation/deactivation. Security services provide declarative security using roles and securing both EJBs and web components requires defining a security domain, login/error pages, and security declarations in deployment descriptors. Transactions services allow distributed transactions across multiple resources.
Metamorphosis from Forms to Java: A technical lead's perspective, part IIMichael Fons
This document provides an overview of key concepts for transitioning from Forms development to Java and ADF, including deployment, the MVC pattern, beans, GUI components, collections vs iterators, and tips. It includes 11 demo sections walking through creating a basic model and UI, visual designer, bindings, passing data between pages, authorization, and extending the framework. The summaries aim to highlight the main topics covered in each section at a high level.
The document provides an overview of the Oracle Application Framework (OA Framework). It describes the OA Framework as the Oracle Applications development and deployment platform built using J2EE technologies. The framework embraces principles like end user productivity, developer productivity, and open standards. It follows a Model-View-Controller architecture and features include an integrated development environment, consistent user interface, and built-in security. The document outlines the framework's components, profile options, required JDeveloper version, and steps to install JDeveloper and connect to an applications schema.
Ajax is a method of employing JavaScript, DHTML, and the XMLHttp behaviour in the
browser to provide truly dynamic content on a Web page without a page refresh. There are
quantifiable benefits to be realized for end users and businesses, which include improved
usability and faster applications. In this tutorial I will look at a simple example using Ajax4JSF
with JSF, Facelets, Maven2 and Eclipse.
This course teaches developers how to build Java EE applications using Oracle Application Development Framework (Oracle ADF). Students will learn to use Oracle JDeveloper 11g to build, test, and deploy a full-stack web application. Key topics include exposing the data model with ADF Faces, creating JSF pages, adding validation, securing applications, building the data model with ADF Business Components, and deploying the application to Oracle WebLogic Server. The goal is for students to become efficient at developing enterprise applications using the Oracle ADF framework.
The document provides an overview of ASP.NET, including its architecture, web server controls, page lifecycle, state management, user controls, AJAX functionality, and how it relates to SharePoint 2010. Key points covered include the benefits of ASP.NET compared to classic ASP, the 3-tier architecture model, events in the page lifecycle, options for client-side and server-side state management, how user controls work, and the ASP.NET AJAX library and controls.
About us
BISP is an IT Training and Consulting Company. We are Subject Matter Experts for DHW and BI technologies. We provide Live virtual Online global IT support and services like online software training, live virtual online lab services, virtual online job support with highly intellectual professional trainers and skilled resources , predominantly In Oracle BI, Oracle Data Integrator, Hyperion Product stack, Oracle Middleware solution, Oracle SoA, AIA Informatica, IBM Datastage and IBM Cognos .
BISP has footprints virtually across USA, CANADA, UK, SINGAPORE, SAUDI ARABIA, AUSTRALIA and more by providing live virtual support services from India for fresh graduates, opt students, working professionals etc. Being a live virtual online training the support , training and service methodology is just click away considerably reducing your TIME,INFRASTRUCTURE and Cost effective.
This document provides an introduction to Java Server Faces (JSF) and the Seam framework, including their architectures, configurations, features, pros, and cons. JSF is a Java specification for building component-based user interfaces for web applications, while Seam extends JSF by adding features like state management, Ajax support, and page flows. The document outlines the MVC architectures of both technologies and demonstrates features like validation, error handling, and data binding through examples. It concludes by discussing advantages of Seam and shortcomings of plain JSF.
This document discusses Oracle Application Development Framework (ADF) task flows. It provides an overview of different types of task flows including bounded and unbounded task flows. It describes the components that make up task flows like view activities, control flow cases, and method execution activities. Best practices for building reusable task flows are also mentioned. The presenter is an Oracle ADF and WebCenter consultant who is passionate about Oracle technologies and has been working with them for over 8 years.
[Www.pkbulk.blogspot.com]file and indexingAnusAhmad
The document discusses data storage and indexing in databases. It covers physical and logical addressing of data blocks, main memory addressing when blocks are read into memory, and the I/O model of computation in databases where I/O time dominates. The document also discusses indexing using B+ trees and hash tables, including insertion, deletion, and searching operations in B+ trees. External sorting algorithms are covered, along with how they are optimized when data does not fit in memory.
Triggers in SQL allow users to specify actions that are automatically performed in response to insert, update, or delete events on a table. Triggers can be defined to execute before, after, or instead of the triggering event. Triggers have access to old and new values of rows that are inserted, updated, or deleted. Care must be taken with triggers on mutating tables to avoid inconsistent data access or infinite recursion.
This document provides an overview of SQL and embedded SQL concepts. It discusses scalar subqueries, embedded SQL programming, transactions, dynamic SQL, and JDBC. Scalar subqueries return single values that can be used in expressions or output clauses. Embedded SQL allows embedding SQL statements in programming languages for connectivity. Transactions define units of work that can be committed or rolled back. Dynamic SQL builds SQL statements dynamically at runtime using strings, while JDBC is the Java database connectivity API.
This document discusses SQL nested queries and aggregation. It provides examples of different types of nested queries using IN, EXISTS, and NOT EXISTS clauses. It explains how to write queries with correlated subqueries that refer to columns in the outer query. It also covers SQL aggregation functions like COUNT, MAX, MIN, SUM, AVG and the GROUP BY clause. It shows how to group query results and apply aggregate functions to each group. The HAVING clause is introduced to filter groups based on aggregate conditions.
SQL is a language for communicating with a database management system (DBMS) to carry out tasks like querying data, inserting/updating/deleting rows, and managing database objects. It includes data definition language (DDL) for creating and modifying database objects and data manipulation language (DML) for querying and modifying data. A SQL database contains tables which have a schema defining columns and their data types, and may have constraints. Queries in SQL use SELECT statements to retrieve data that matches conditions specified in the WHERE clause by comparing column values and expressions.
This document discusses the entity-relationship (E-R) model for conceptual database design. It defines entities, attributes, relationships and cardinalities. Entities are mapped to relations, with attributes and keys. Relationships are mapped based on cardinality, such as creating a new relation for many-to-many relationships. The document provides examples of mapping auction database entities and relationships to tables. It also covers weak entities, generalization hierarchies, and extensions to the basic relational model.
The document discusses the relational model of databases. It defines key concepts like relations, tuples, attributes, domains, and keys. It provides an example database schema for an auction application with relations for owners, items, bids, and buyers. It explains that a relation is a set of tuples with a common schema where each tuple maps attribute names to values from predefined domains. It also defines the different types of keys like superkeys and primary keys.
This document discusses query optimization in database systems. It begins by describing the components of a database management system and how queries are processed. It then explains that the goal of query optimization is to reduce the execution cost of a query by choosing efficient access methods and ordering operations. The document outlines different query plans involving table scans, index scans, and joins. It also introduces concepts like filter factors, statistics about tables and indexes, and how these are used to estimate the cost of alternative query execution plans.
JSP (Java Server Pages) Lecture # 5
Breif detail lecture about the JSP Servlets with example code the tutorial thing such as how to create, deploy etc etc
This document provides information on Java applets including:
- An applet is a Java program that runs in a web browser context
- It must extend the Applet class or JApplet class
- Includes the applet lifecycle of loading, creating, initializing, starting, stopping, and destroying
- Provides sample code for creating a basic "MyApp" applet class and embedding it in an HTML page
- Discusses restrictions on applets and demonstrates creating an applet project in NetBeans
This document outlines a course on web engineering taught by Imran Daud. It covers topics like HTTP architecture, HTML, Java applets, JSP, Java servlets, and JavaScript. The course marks are distributed as follows: projects/assignments/quizzes 15%, midterm 30%, attendance 5%, and final exam 50%. It also provides information on Java fundamentals like what packages and classes are, how to write, compile, and run a Java program, and an introduction to object-oriented programming concepts in Java.
Multi-currency in odoo accounting and Update exchange rates automatically in ...Celine George
Most business transactions use the currencies of several countries for financial operations. For global transactions, multi-currency management is essential for enabling international trade.
How to track Cost and Revenue using Analytic Accounts in odoo Accounting, App...Celine George
Analytic accounts are used to track and manage financial transactions related to specific projects, departments, or business units. They provide detailed insights into costs and revenues at a granular level, independent of the main accounting system. This helps to better understand profitability, performance, and resource allocation, making it easier to make informed financial decisions and strategic planning.
This chapter provides an in-depth overview of the viscosity of macromolecules, an essential concept in biophysics and medical sciences, especially in understanding fluid behavior like blood flow in the human body.
Key concepts covered include:
✅ Definition and Types of Viscosity: Dynamic vs. Kinematic viscosity, cohesion, and adhesion.
⚙️ Methods of Measuring Viscosity:
Rotary Viscometer
Vibrational Viscometer
Falling Object Method
Capillary Viscometer
🌡️ Factors Affecting Viscosity: Temperature, composition, flow rate.
🩺 Clinical Relevance: Impact of blood viscosity in cardiovascular health.
🌊 Fluid Dynamics: Laminar vs. turbulent flow, Reynolds number.
🔬 Extension Techniques:
Chromatography (adsorption, partition, TLC, etc.)
Electrophoresis (protein/DNA separation)
Sedimentation and Centrifugation methods.
A measles outbreak originating in West Texas has been linked to confirmed cases in New Mexico, with additional cases reported in Oklahoma and Kansas. The current case count is 795 from Texas, New Mexico, Oklahoma, and Kansas. 95 individuals have required hospitalization, and 3 deaths, 2 children in Texas and one adult in New Mexico. These fatalities mark the first measles-related deaths in the United States since 2015 and the first pediatric measles death since 2003.
The YSPH Virtual Medical Operations Center Briefs (VMOC) were created as a service-learning project by faculty and graduate students at the Yale School of Public Health in response to the 2010 Haiti Earthquake. Each year, the VMOC Briefs are produced by students enrolled in Environmental Health Science Course 581 - Public Health Emergencies: Disaster Planning and Response. These briefs compile diverse information sources – including status reports, maps, news articles, and web content– into a single, easily digestible document that can be widely shared and used interactively. Key features of this report include:
- Comprehensive Overview: Provides situation updates, maps, relevant news, and web resources.
- Accessibility: Designed for easy reading, wide distribution, and interactive use.
- Collaboration: The “unlocked" format enables other responders to share, copy, and adapt seamlessly. The students learn by doing, quickly discovering how and where to find critical information and presenting it in an easily understood manner.
How to Manage Opening & Closing Controls in Odoo 17 POSCeline George
In Odoo 17 Point of Sale, the opening and closing controls are key for cash management. At the start of a shift, cashiers log in and enter the starting cash amount, marking the beginning of financial tracking. Throughout the shift, every transaction is recorded, creating an audit trail.
INTRO TO STATISTICS
INTRO TO SPSS INTERFACE
CLEANING MULTIPLE CHOICE RESPONSE DATA WITH EXCEL
ANALYZING MULTIPLE CHOICE RESPONSE DATA
INTERPRETATION
Q & A SESSION
PRACTICAL HANDS-ON ACTIVITY
CBSE - Grade 8 - Science - Chemistry - Metals and Non Metals - WorksheetSritoma Majumder
Introduction
All the materials around us are made up of elements. These elements can be broadly divided into two major groups:
Metals
Non-Metals
Each group has its own unique physical and chemical properties. Let's understand them one by one.
Physical Properties
1. Appearance
Metals: Shiny (lustrous). Example: gold, silver, copper.
Non-metals: Dull appearance (except iodine, which is shiny).
2. Hardness
Metals: Generally hard. Example: iron.
Non-metals: Usually soft (except diamond, a form of carbon, which is very hard).
3. State
Metals: Mostly solids at room temperature (except mercury, which is a liquid).
Non-metals: Can be solids, liquids, or gases. Example: oxygen (gas), bromine (liquid), sulphur (solid).
4. Malleability
Metals: Can be hammered into thin sheets (malleable).
Non-metals: Not malleable. They break when hammered (brittle).
5. Ductility
Metals: Can be drawn into wires (ductile).
Non-metals: Not ductile.
6. Conductivity
Metals: Good conductors of heat and electricity.
Non-metals: Poor conductors (except graphite, which is a good conductor).
7. Sonorous Nature
Metals: Produce a ringing sound when struck.
Non-metals: Do not produce sound.
Chemical Properties
1. Reaction with Oxygen
Metals react with oxygen to form metal oxides.
These metal oxides are usually basic.
Non-metals react with oxygen to form non-metallic oxides.
These oxides are usually acidic.
2. Reaction with Water
Metals:
Some react vigorously (e.g., sodium).
Some react slowly (e.g., iron).
Some do not react at all (e.g., gold, silver).
Non-metals: Generally do not react with water.
3. Reaction with Acids
Metals react with acids to produce salt and hydrogen gas.
Non-metals: Do not react with acids.
4. Reaction with Bases
Some non-metals react with bases to form salts, but this is rare.
Metals generally do not react with bases directly (except amphoteric metals like aluminum and zinc).
Displacement Reaction
More reactive metals can displace less reactive metals from their salt solutions.
Uses of Metals
Iron: Making machines, tools, and buildings.
Aluminum: Used in aircraft, utensils.
Copper: Electrical wires.
Gold and Silver: Jewelry.
Zinc: Coating iron to prevent rusting (galvanization).
Uses of Non-Metals
Oxygen: Breathing.
Nitrogen: Fertilizers.
Chlorine: Water purification.
Carbon: Fuel (coal), steel-making (coke).
Iodine: Medicines.
Alloys
An alloy is a mixture of metals or a metal with a non-metal.
Alloys have improved properties like strength, resistance to rusting.
*Metamorphosis* is a biological process where an animal undergoes a dramatic transformation from a juvenile or larval stage to a adult stage, often involving significant changes in form and structure. This process is commonly seen in insects, amphibians, and some other animals.
How to Customize Your Financial Reports & Tax Reports With Odoo 17 AccountingCeline George
The Accounting module in Odoo 17 is a complete tool designed to manage all financial aspects of a business. Odoo offers a comprehensive set of tools for generating financial and tax reports, which are crucial for managing a company's finances and ensuring compliance with tax regulations.
The Pala kings were people-protectors. In fact, Gopal was elected to the throne only to end Matsya Nyaya. Bhagalpur Abhiledh states that Dharmapala imposed only fair taxes on the people. Rampala abolished the unjust taxes imposed by Bhima. The Pala rulers were lovers of learning. Vikramshila University was established by Dharmapala. He opened 50 other learning centers. A famous Buddhist scholar named Haribhadra was to be present in his court. Devpala appointed another Buddhist scholar named Veerdeva as the vice president of Nalanda Vihar. Among other scholars of this period, Sandhyakar Nandi, Chakrapani Dutta and Vajradatta are especially famous. Sandhyakar Nandi wrote the famous poem of this period 'Ramcharit'.
How to Set warnings for invoicing specific customers in odooCeline George
Odoo 16 offers a powerful platform for managing sales documents and invoicing efficiently. One of its standout features is the ability to set warnings and block messages for specific customers during the invoicing process.
A measles outbreak originating in West Texas has been linked to confirmed cases in New Mexico, with additional cases reported in Oklahoma and Kansas. The current case count is 817 from Texas, New Mexico, Oklahoma, and Kansas. 97 individuals have required hospitalization, and 3 deaths, 2 children in Texas and one adult in New Mexico. These fatalities mark the first measles-related deaths in the United States since 2015 and the first pediatric measles death since 2003.
The YSPH Virtual Medical Operations Center Briefs (VMOC) were created as a service-learning project by faculty and graduate students at the Yale School of Public Health in response to the 2010 Haiti Earthquake. Each year, the VMOC Briefs are produced by students enrolled in Environmental Health Science Course 581 - Public Health Emergencies: Disaster Planning and Response. These briefs compile diverse information sources – including status reports, maps, news articles, and web content– into a single, easily digestible document that can be widely shared and used interactively. Key features of this report include:
- Comprehensive Overview: Provides situation updates, maps, relevant news, and web resources.
- Accessibility: Designed for easy reading, wide distribution, and interactive use.
- Collaboration: The “unlocked" format enables other responders to share, copy, and adapt seamlessly. The students learn by doing, quickly discovering how and where to find critical information and presenting it in an easily understood manner.
CURRENT CASE COUNT: 817 (As of 05/3/2025)
• Texas: 688 (+20)(62% of these cases are in Gaines County).
• New Mexico: 67 (+1 )(92.4% of the cases are from Eddy County)
• Oklahoma: 16 (+1)
• Kansas: 46 (32% of the cases are from Gray County)
HOSPITALIZATIONS: 97 (+2)
• Texas: 89 (+2) - This is 13.02% of all TX cases.
• New Mexico: 7 - This is 10.6% of all NM cases.
• Kansas: 1 - This is 2.7% of all KS cases.
DEATHS: 3
• Texas: 2 – This is 0.31% of all cases
• New Mexico: 1 – This is 1.54% of all cases
US NATIONAL CASE COUNT: 967 (Confirmed and suspected):
INTERNATIONAL SPREAD (As of 4/2/2025)
• Mexico – 865 (+58)
‒Chihuahua, Mexico: 844 (+58) cases, 3 hospitalizations, 1 fatality
• Canada: 1531 (+270) (This reflects Ontario's Outbreak, which began 11/24)
‒Ontario, Canada – 1243 (+223) cases, 84 hospitalizations.
• Europe: 6,814
The *nervous system of insects* is a complex network of nerve cells (neurons) and supporting cells that process and transmit information. Here's an overview:
Structure
1. *Brain*: The insect brain is a complex structure that processes sensory information, controls behavior, and integrates information.
2. *Ventral nerve cord*: A chain of ganglia (nerve clusters) that runs along the insect's body, controlling movement and sensory processing.
3. *Peripheral nervous system*: Nerves that connect the central nervous system to sensory organs and muscles.
Functions
1. *Sensory processing*: Insects can detect and respond to various stimuli, such as light, sound, touch, taste, and smell.
2. *Motor control*: The nervous system controls movement, including walking, flying, and feeding.
3. *Behavioral responThe *nervous system of insects* is a complex network of nerve cells (neurons) and supporting cells that process and transmit information. Here's an overview:
Structure
1. *Brain*: The insect brain is a complex structure that processes sensory information, controls behavior, and integrates information.
2. *Ventral nerve cord*: A chain of ganglia (nerve clusters) that runs along the insect's body, controlling movement and sensory processing.
3. *Peripheral nervous system*: Nerves that connect the central nervous system to sensory organs and muscles.
Functions
1. *Sensory processing*: Insects can detect and respond to various stimuli, such as light, sound, touch, taste, and smell.
2. *Motor control*: The nervous system controls movement, including walking, flying, and feeding.
3. *Behavioral responses*: Insects can exhibit complex behaviors, such as mating, foraging, and social interactions.
Characteristics
1. *Decentralized*: Insect nervous systems have some autonomy in different body parts.
2. *Specialized*: Different parts of the nervous system are specialized for specific functions.
3. *Efficient*: Insect nervous systems are highly efficient, allowing for rapid processing and response to stimuli.
The insect nervous system is a remarkable example of evolutionary adaptation, enabling insects to thrive in diverse environments.
The insect nervous system is a remarkable example of evolutionary adaptation, enabling insects to thrive
4. JSF Managed Bean
Getter & Setter for user and pass
checkUser function to validate user.
5. Configure faces-config.xml file
Open subject file and Right click
Insert-> navigation rule
select view that is your main index file that contains form.
Again right click then insert ->navigation cause
From outcome contains return string from bean
To view contains page where it should be redirected against
the outcome.