Saved Searches

    You have no Saved Searches ...

    Breadcrumb

    Search Results

    All

    Results Timeline Dynamic

    • This tutorial covers how to implement Java Message Service 2.0 (JMS 2.0) shared nondurable subscriptions and shared durable subscriptions in the Java Platform, Standard Edition (Java SE) environment. 

       
    • This tutorial demonstrates how to develop a sample Java EE7 batch application and run the batch application in Oracle GlassFish Server4.0.

       
    • This tutorial covers how to use the non-blocking I/O functionality with GlassFish and NetBeans. Non-blocking I/O was introduced in Servlet 3.1, a new API i Java EE 7.

       
    • This series highlights Java EE 7 and its new features.

       
    • This tutorial and video series shows you how to create an application that uses the WebSocket API for real-time communication between a client and a server.

       
    • This tutorial shows you how to create an application that uses the WebSocket API for real-time communication between a client and a server.

       
    • This multi-part series introduces you to the Java EE 6 Contexts and Dependency Injection feature.

       
    • This two-part series describes how to work with the Java Persistence API in an application using NetBeans 7.

       
    • CDI is one of several Java EE 6 features that help to integrate the web tier and the enterprise tier of the Java EE platform. CDI is a set of services that, used together, make it easy for developers to use enterprise beans along with JavaServer Faces technology in web applications. CDI also has many broader uses, allowing developers a great deal of flexibility to integrate various kinds of components in a loosely coupled but typesafe way.

      A CDI stereotype allows you to create a annotation that club together several  CDI annotations. For example, if we needed to create several CDI named beans with a scope of session, we would have to use two annotations in each of these beans,
      namely @Named and @SessionScoped. Instead of providing two annotations to each of the beans, you would create a stereotype, and then annotate the beans with it.

      Stereotypes can be particularly useful in large applications where you have a number of beans that perform similar functions.

       
    • This example demonstrates implementing CRUD database operations using  Java Persistence API  for desktop applications.

      The Java Persistence API provides Java developers with an object/relational mapping facility for managing relational data in Java applications. Some of the features of JPA are

      • You won't have to create complex data access objects (DAO).
      • The API helps you manage transactions.
      • JPQL is database agnostic, freeing you from vendor-specific code.
      • JPQL is portable whereas SQL is not.
      • You can avoid SQL in preference to a query language, JPQL that uses your class names and properties.
      • You can also use the Java Persistence API for desktop application persistence.

      In this tutorial, you will create java client programs to demonstrate the following CRUD operations- Retrieve, Update and Delete operations using Entity clases. The Create operation is covered in Using Java Persistence API for Java SE 7 Desktop applications in NetBeans 7- Part 1.

       
    • Events are an important part of the JavaBeans model. You have probably used events in Abstract Windowing Toolkit (AWT) and Swing applications by registering a listener on a component. When you click the component (like a button), an event is fired and handled by the registered listener.

      Contexts and Dependency Injection (CDI) was introduced with Java Platform, Enterprise Edition (Java EE) 6 as JSR-299. The Contexts part of CDI allows beans to share and participate in the life cycle of another bean, while the Dependency Injection part of CDI allows beans to get a reference to an instance of another bean simply by injecting it. CDI power is the ability to loosely-couple classes by removing the instantiation process and simultaneously enforcing strong-type checking. CDI provides an @Inject annotation to create a reference to another bean (avoiding the older context lookup process). CDI enforces typing by eliminating string-based lookup so that the compiler can detect errors. CDI works very well with integrated development environments (IDE's).

      The CDI event model allows beans to send events to one another without a compile-time dependency, and beans may create their own event payloads - a class that contains information pertinent to the event. Using CDI events, one bean can define the event, another can fire the event and a third can handle the event. And unlike with other event models, you can add listeners (observers) without registering them as listeners.

       
    • Contexts and Dependency Injection (CDI) was introduced with Java Platform, Enterprise Edition (Java EE) 6 as JSR-299. The Contexts part of CDI allows beans to share and participate in the life cycle of another bean, while the Dependency Injection part of CDI allows beans to get a reference to an instance of another bean simply by injecting it. CDI power is the ability to loosely couple classes by removing the instantiation process and simultaneously enforcing strong-type checking. CDI provides an @Inject annotation to create a reference to another bean (avoiding the older context lookup process). CDI enforces typing by eliminating string-based lookup so that the compiler can detect errors. CDI works very well with integrated development environments (IDEs).

      This tutorial looks at a particular kind of CDI service called an interceptor. An interceptor is invoked prior to the invocation of a method on which the interceptor binding annotation is placed. Interceptors are very useful for tasks that need to be applied to several methods without adding more code to the existing methods. These tasks are often referred to as cross-cutting tasks. Logging and auditing are examples of tasks that cut across business methods,

      In this tutorial, you create an interceptor binding type, which is an annotation used to associate an interceptor with either a method or a bean class. The interceptor binding type is also associated with an interceptor class that contains a single method annotated with @AroundInvoke.

       
    • EJB Lite is a subset of the features of  EJB 3.1.  An embeddable enterprise bean container supports EJB Lite and can run within a Java SE application in the same JVM. So one can run EJB outside an application server and a Java SE client can access the EJB locally.
      The embedded enterprise bean container is typically used for testing enterprise beans without having to deploy them to a server. Enterprise bean components execute similarly in both embedded and Java EE environments, and therefore the same enterprise bean can be easily reused in both standalone and networked applications.

      JPA provides Java developers with an object/relational mapping facility for managing relational data in Java applications.JPA can be used in a standalone Java application and in an enterprise application.

      In this tutorial, you will develop a Java SE client that invokes a stateless EJB which is running in an embedded container in the same JVM as the Java client. The EJB will use a JPA entity to insert data into a database. The name of the Java application is ProductManager and it invokes ProductEJB which uses Product JPA entity to insert product data into the Product table.

       
    • This tutorial covers  creating an EJB 3.1  singleton session bean and exposing the singleton session bean  as a JAX-WS web service and  consuming the web service using different types of web service clients.

      In this tutorial, you will create a Java EE 6 Web Application and add the following components to it - a singleton session bean, CounterBean and implement a getHits() method in it. The singleton session bean provides a central counter service.  Next you will expose the singleton session bean as  a JAX-WS web service called CounterService. You will deploy the web service to GlassFish server and test the web service  You will develop two clients to consume this web service - a Java class in a  Java SE application  and a jsp page in a web application.

       
    • In this tutorial, you will be implementing a Java Message Service Publish/Subscribe system. The user interface components, a JavaServer Faces (JSF) page and managed bean have already been developed. Your task is to create a second managed bean to produce a message from the data in the form, and publish it to a JMS topic. You will then create message-driven beans (MDBs) that subscribe to the topic and use a message selector to filter the messages depending upon the value of a message property.

       

    Filters

    Search Criteria