• Single tier applications are easier to design. Single tier applications mix data, presentation, business logic altogether. It is easier design but workload distribution becomes difficult. Moreover, software maintenance becomes a big headache.
• Multi-tier applications can address these challenges. Here, the application, hence, the workload is divided into multiple modules – tiers. The presentation, data, business logic can be separated from each other. This provides well organized software development. The workload can be divided among several developers more effectively. Also, software maintenance becomes easier.
• Multitiered Applications Benefits:
  • Availability: Accessible at all times – more accessible. Move parts of your applications into separate machines
  • Extensibility: Ability to add more capabilities. Can add more capabilities without breaking the systems
  • Scalability: Support more users: Add extra computing resources to each layer,
  • Reliability: Maintain the accuracy and integrity of the data. Separating business logic from the rest of the applications, grouping operations into transactions
  • Maintainability: Ability to update software code
• Design considerations for Distributed Applications/Systems
  • Event handling: Generation and notification of distributed events
  • Persistence: How distributed objects are stored and accessed
  • Concurrency: Acquiring and releasing locks in distributed environments
  • Security: Mechanisms to provide distributed authentications, authorization, encryption, and auditing
  • Transactions:
  • Language dependencies
  • Platform dependencies : Provide seamless operations irrespective of the underlying OSs or processors
• Distributed object management issues:
  • Create and delete distributed objects
  • Reliable communications among distributed objects
  • Provide interfaces for object mapping
  • Activating distributed objects and binding them to names
  • Advertising and accessing objects and services
• Design distributed systems:
  • Partition the problem into modular
  • Make the module small enough to be individually solvable
  • Findout the application and communication layers/requirements
• Transaction Management

From: http://sitestree.com/?p=4983
Categories:Java Short Notes
Tags:
Post Data:2006-12-04 23:22:04

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

Core J2EE Component Technologies

• J2EE Application Components: Web Components, Business Components
• Web-Component:
  • Software entity hosted by a web-container on a J2EE Server
  • Generate user interface for web-based applications
  • Two Types: Servlets, JSPs
  • Servlets: Process requests dynamically, format responses
  • JSPs: How to process requests, and format responses
• Business Components: EJB Components or enterprise beans: Contain business logic of an enterprise application. Three types: Session Beans, Entity Beans, Message Beans

J2EE Services

• Distributed Communication Services:
  • Distributed Communication Services provide J2EE components distributed communications capability and EIS access
  • Web-container Service Components: JMS, JNDI, RMI-IIOP,CORBA and Java IDL
  • Roughly: RMI-IIOP, CORBA and Java IDL: Applet and Application Container to Web-Container Communications
  • JMS, JNDI: Between web-container and EJB container components. For application components not for users
  • JNDI: Naming and directory services.
  • CORBA: Objects to communicate regardless of their implementation language or the operating system
  • Java IDL API enables J2EE applications to utilize CORBA functionality
• Other support technologies
  • JDBC, Java Transaction API, Java Transaction Service, J2EE Connectors, JavaMail
  • JDBC: Provides database access from Java.
  • Latest JDBC: Provides connection pooling and distributed transaction support for the J2EE platform
  • JDBC Drivers: Java, Partial Java, Java Native Interface (JNI)
  • J2EE connector architecture provides supports to connect to EISs
  • JavaMail API to handle mailing

From: http://sitestree.com/?p=4982
Categories:Java Short Notes
Tags:
Post Data:2012-10-30 12:18:39

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• Design Patterns
  • What are design patterns? Design patterns are specific/(context-based) solutions/approaches to address specific problems/situations. Some problems are general/open problems and very common problems in a particular type of applications. Design patterns can be created to solve such problems in a specific context and that can be re-used every time that type of situations arise. Design patterns help designers to easily communicate their ideas (in a common concept).
  • Benefits: Proven solution to a specific problem, saves time as you don’t have to come up with an original solution each time you encounter a particular problem
  • Design patterns can be applied at different levels of abstractions such as, Analysis, Architectural, Behavioral, Creational, Design, and Structural
  • J2EE patterns are mostly for design and architecture purpose and for three architectural tiers: Presentation, Business, and Integration
• J2EE Applications: Client Tier (Clients for J2EE Applications): Design Issues
  • J2EE supports many types of clients. Hence, you need to decide which types of clients you want to make use of. Also, based on the clients you need to decide how to solve a specific problem. Design patterns can be client-specific and problem-specific
  • J2EE clients: laptops, desktops, palmtops, and cell phones.
  • Connection Mechanisms (to J2EE Applications): an intranet, the Internet, a wireless network, a wired network, and a combination of wired and wireless networks
  • Clients can be thin, server dependent, browser based, rich, and stand-alone
  • Client design issues: Concerns: which types of clients to use, should more than one type of clients be supported?, network types to support, security considerations, platform considerations, and unreliability of networks
  • Clients should: Connect to the network on an ad-hoc basis, transmit minimum amount of data, should consider situations when firewalls may block particular protocols, mobile clients should consider that they have small display screens and limited resources
  • More design issues for J2EE clients: Logic for user interface presentation, validate user inputs, communicate with the server using a common protocol, maintain the conversational state
  • Browser clients – design issues: can not function independently of the server, easy to design and implement, widely available, well-familiar to the users, provide limited functionality, can perform user input validation, servers can also do the validation, uses HTTP protocol, needs to maintain conversational states using Cookies, URL rewriting, or server side session
  • Java clients – design issues:
  • Client types: applications, applets, MIDlets are the Java client options
  • Applications like usual desktop applications – can run offline, use JFC/Swing for user interface, provide richer user experience, more responsive than thin clients, use less bandwidth than browser clients, and can create fewer connections than browser clients
  • Applets run mostly under browsers, use JFC/Swing for user interface
  • MIDlets are mostly for small applications for cell phones, two-way pagers, and palmtops – use MIDP user interface APIs
  • Java clients (Applications, applets, MIDlets) can handle most user input validation and hence, reduce network overhead, can connect to J2EE applications, directly to the web tier (using HTTP though face some complexity of translation), EJBs, EISs,
  • Applets and applications can connect to EJBs directly,
  • Java clients can access EIS tier directly (not recommended as it would bypass J2EE server and transaction management)
  • Java clients have the facility to cache and manipulate large amounts of state in memory and manage session effectively
• Web Tier
  • Servlets, and JSPs are web-tier component
  • Manage the interaction between web-clients and the application’s business logic.
  • Output from this tier: mostly HTML and XML content
  • Business logic can be implemented entirely here, though, enterprise beans are recommended
  • Servlets should be used to: implement web-application logic, generate binary content, act as a web-tier controller
  • JSPs are better suited to generate static HTML text
  • JSP Purpose: produce structured textual content, generate XML messages, act as templates
  • In JSP, custom tags are more desirable than scriptlets. Why? scriplets – not reusable, mix logic with content, make JSP pages difficult to read and update, errors can be difficult to interpret, difficult to test (including unit testing)
  • Web-Tier Application Framework
    • Many web-tier application requirements are not met by the actual J2EE platform. A framework working on top of J2EE can meet these requirements such as, dispatching requests, invoking model methods, and compiling views.
    • Making use of existing ready-built and proven application framework is recommended than creating your own [it takes time and may be all your designs will not be the best]
    • Some frameworks: J2EE blueprints Web Application Framework, Apache Struts, JavaServer Faces
  • Model View Controller (MVC)
    • Well-suited for interactive applications such as web-applications.
    • Divides applications into three modules – model, view, controller
    • model: data representation and business logic, view: data presentation and user input, controller: controls information flow
    • Benefits: separation of design and implement, decreased code duplication, centralized control
    • Servlets are ideal as controllers
    • Controllers receive all incoming client requests and direct them to the appropriate business logic component, after processing the requests, the controller selects the right view to return to the client.
  • Model 1 and Model 2
    • Model 1: No controller, direct access to the JSP pages, decentralized application, simpler and hence suited for small and static applications
    • Model 2: Uses a controller, are favored as they are easy to maintain and extend, provide a single point for security and logging
• EJB Tier
  • Hosts business logic of a J2EE application
  • Provides system level services to the business components
  • Developers can focus on business-logic problems
  • J2EE platform handles the system related problems (complex many times) such as, state maintenance, transaction management, and availability to local and remote clients
  • EJBs provide a good interface between presentation components in the web-tier and business data and systems in the EIS tier
  • EJBs – entity, session, message driven
  • EJBs can provide remote or local access by providing remote or local interfaces. EJBs are mostly designed for distributed environments and hence typically provide remote interfaces
  • When to use entity beans: for business objects when it represents persistent data and requires persistent storage, multiple client access, data access in portable manners, server managed transaction handling is preferable
  • Entity beans: Persistence can be managed by yourself or by the EJB container
  • When to use Stateful Session-beans: for client centric business logic, business objects are short-lived, and non-persistent. Works for the client to maintain conversational state
  • When to use Stateless session beans: Provide server side behavior, do not maintain states for a specific client, good for reusable service objects, to minimize resources and support a large number of clients, when the business object does not operate on instance variables.
• EIS Tier
  • J2EE EIS technologies: J2EE Connectors to integrate J2EE applications with existing EISs using resource adapters – synchronous
  • Java Message Service: To be used with enterprise messaging systems – asynchronous
  • JDBC – integrates J2EE applications with relational database systems
  • asynchronous: high quality and reliable message-delivery service, provide higher volume of messaging, more work for the developers
  • synchronous – suitable to handle two or more EISs synchronously.

From: http://sitestree.com/?p=4981
Categories:Java Short Notes
Tags:
Post Data:2009-07-13 18:40:32

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• Java EE Code Samples & Apps

From: http://sitestree.com/?p=4978
Categories:Java Short Notes
Tags:
Post Data:2010-07-02 21:17:05

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• Security Services Provide
  • Data Integrity
  • Data Confidentiality
  • Access Control – Authentication and Authorization
• Encryption helps to provide such security services
• Core Java Security Architecture
  • — Core Java 2 Security Architecture
  • — Java Cryptography Architecture (JCA)
  • — Java Cryptography Extension (JCE)
  • — Java Secure Socket Extension (JSSE)
  • — Java Authentication and Authorization Service
  • — JCE and JSSE extends JCA
• JCA – Platform Packages
  • java.security – core security classes and interfaces
  • java.security.cert – certificate management
  • java.security.interfaces – Interfaces used to manage DSA and RSA keys
  • java.security.spec – key specification, algorithm parameter specification
• JCA – not useful for data encryption
• JCE provides the data encryption
• JCE packages: javax.crypto, javax.crypto.interfaces, javax.crypto.spec
• JSSE includes a Java implementation of SSL and Transport Layer Security (TLS) – server authentication, message integrity, optional client authentication.
• JSSE Packages:javax.net.ssl,javax.net,javax.security.cert
• JAAS : limit access to resources based on user identity. JAAS implements PAM (Pluggable Authentication Module Framework) – user-based, group-based, role-based access control
• JAAS packages:javax.security.auth,javax.security.auth.callback, javax.security.auth.login,javax.security.auth.spi
• Core Security
  • java.security.Permission, PermissionCollection, Permissions – specify level of access to resources in J2EE applications
  • Permissions – sets of diverse permissions
  • Permission Example:
  • Permission has many subclasses like FilePermission, SerializablePermission, SocketPermission, NetPermission
  • FilePermission prm = new FilePermission(“c:test.img”,”read,write”);
  • Security Policy – list permissions in filesSystem Policy – jre/lib/security/java.policy fileUser Policy – java.policy file under user’s directory
  • Java 2 has a policy tool under [JAVA_HOMEbinpolicytool]- GUI based – to create/edit policy files – type policytool in the command prompt
  • Java Security Manager – determines whether requests to the access valued resources should be allowed? – core java security classes also ask security manager
  • For access permission check
  • Access Controller controls access to critical system resources. Security Manager calls Access Controller methods to delegate tasks
• J2EE Application Security
  • J2EE Role Based Security
  • J2EE applications can contain both protected and unprotected resources. Access to the protected resources can be controlled using authorization mechanisms.
  • Authorization
    • Identification : recognize an entity – device or person
    • Authentication : process to identify
  • Role based security: create logical privileges known as roles – may be based on customer/user/job profile
  • Users are grouped together into the roles – same role users into the same role group
  • Creating roles for J2EE Applications:Create roles, associate them with an application, WAR file, JAR files
  • At the time of deployment, the deployer maps roles to the security identities
  • Principle: identity assigned to a user or group after authentication
  • A tool named deploytool can be used to add users and groups to a J2EE server.
  • You can get J2EE and deploytool at: http://java.sun.com/javaee/downloads/index.jsp
  • In deploytoolmenu->tools->server configuration->select users from left -> select reals from right ->
  • Provide ID/Password for the user. Assign a group to the user. – Rest will be common sense, play with the tool
  • You can also use realmtool to add users and groupsexample: realmtool -add 5006 5006admin admin,staffSyntax: -add user password groupsadd, import, userGroups
  • Under deployment tool, afterwards, you can apply permissions to the different applications. You can also view and modify the descriptor file from : menu->tools>view configuration.

From: http://sitestree.com/?p=4977
Categories:Java Short Notes
Tags:
Post Data:2006-12-17 23:47:44

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• Web component information sharing: web context (ServletContext), request, session, and page
• ServletContext – Scope: entire web-application (Servlets & JSPs)
• page/PageContext : A single point of access for many of the attributes of a JSP page
• For each access of the servlet a thread is created. In applications a thread can be accessed concurrently by many threads.
• If the servlet accesses and edits some external resources, then data inconsistency, and data loss may occur
• Synchronized access should help:
• public class TestServlet extends HttpServlet implements SingleThreadModel will provide synchronization and concurrency
• In JSP, you can include – to provide thread safety
• For SingleThreadModel: you still have to synchronize access to class variables and to any shared resources that are stored outside the servlet. example:

   synchronized(sharedResource) { }

• For high-traffic servlets, you should use explicit synchronization blocks rather than implementing SingleThreadModel
• Synchronization is only an issue if the servlet accesses external data resources — returns data from another source: not for a servlet that just performs a task with no data access

From: http://sitestree.com/?p=4966
Categories:Java Short Notes
Tags:
Post Data:2007-03-19 19:26:45

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada

• EJBs can be used to create enterprise applications like banking systems. Clients will interact with such systems for operations like: withdraw cash, transfer cash, pay bills
• When clients directly access EJBs it poses concerns such as: security risks, firewall blocking, EJB architecture becomes transparent to the clients
• Servlets can act as the middleman between the EJBs and clients.
  • Change to EJB becomes easier – hidden from the user
  • Data in EJB better protected
  • Central control of EJBs
• When servlets work as the proxy, smaller devices become capable to access EJBs through http protocol (light weight protocol – good for smaller devices )
• Servlets can work as a front controller
• Supports different types of clients
• Better separation of responsibilities that is desirable – web: flow control logic, EJBs: business logic, EIS: Enterprise Information Systems
• Remember: servlets can be bottlenecks here, better servlet design strategy is required – synchronization may help
• For small applications – may be overkill

How to use EJBs from servlets

• Think about a banking system implemented in EJBs.
• Entity beans = Customers, Accounts
• Session beans = operations like withdraw cash
• In this scenario, servlets can call the session beans and return the results to the clients
• A sample servlet to access the EJBs: Here remote ejbs are assumed : EJB2 is assumed : just example is shown – the coding style may not be great … just an example

• // for remote references to objects such as EJBsimport javax.rmi.PortableRemoteObject;//banking system ejb packageimport bankingSystemEjbClasses.*;import java.io.*;import javax.servlet.*;import javax.servlet.http.*;import javax.naming.*;public class ServletEjb extends HttpServlet{   public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{  float credit = 10;  float debit = 20;  String custName = "";  float initBalance = 0, endBalance = 0;  try{      //locate and instantiate the account manager bean      Context context = new InitialContext();      Object ref = context.lookup("AccountManager");      AccountManagerHome accountManagerHome = (AccountManagerHome) PortableRemoteObject.narrow (ref, AccountManagerHome.class);      AccountManager accountManager  = accountManagerHome.create(); //create a savings account and manipulate itaccountManager.createSavingsAccount(1,"John Smith")  initBalance = accountManager.getInitialBalance("1");//create customeraccountManager.createCustomer(1,"John Smith")  custName = accountManager.getCustomerName();//generate outputresponse.setContentType("text/html");PrintWriter out = response.getWriter();out.println("");out.println("");out.println("Customer Name:" + custName);out.println("Initial Balance:" + initBalance);out.println("");out.println("");  }catch(Exception ex){}}}

From: http://sitestree.com/?p=4965
Categories:Java Short Notes
Tags:
Post Data:2010-04-10 03:31:53

Shop Online: https://www.ShopForSoul.com/
(Big Data, Cloud, Security, Machine Learning): Courses: http://Training.SitesTree.com
In Bengali: http://Bangla.SaLearningSchool.com
http://SitesTree.com
8112223 Canada Inc./JustEtc: http://JustEtc.net (Software/Web/Mobile/Big-Data/Machine Learning)
Shop Online: https://www.ShopForSoul.com/
Medium: https://medium.com/@SayedAhmedCanada