Festín Tecnológico

Simple Http Server with Docker

2016-12-08T16:24:00.001-08:00

1. Create a simple php file (index.php)

echo "This is an example"
?>

2. Create Dockerfile with the configurations

FROM php:7.0-apache
COPY src/ /var/www/html/
EXPOSE 80

3. Run de command to build the image in the cuurent directory
docker build -t example .

4. Run the command to expose the app through the port 8080 on the host machine
docker run -p 8080:80 example

5. to mount the volume run the command
docker run -p 8080:80 -v ~/projects/dockerExample/src/:/var/www/html/ example

Routing with Angular2

2016-05-10T17:36:00.001-07:00

1. Create a default template with the following tutorial http://festintecnologico.blogspot.com.au/2016/05/setup-of-environment-with-vs-code-for.html

2. Add <base href="/"> before the body tag on index.html

3.Create a file named default.component.ts in the app directory with the following content:
import {Component} from "@angular/core"

@Component({
selector:'default',
template:'Welcome to Default Component'
})
export class DefaultComponent{

}

4. Create a file named first-example.component.ts in the app directory with the following content:
import { Component } from '@angular/core';

@Component({
selector:'myTag',
template:'This is a test'
})
export class FirstExampleComponent{

}

5. Open main.ts add

import {ROUTER_PROVIDERS} from "@angular/router"

and modify bootstrap to

bootstrap(AppComponent,[ROUTER_PROVIDERS]);

The file should look like:
import { bootstrap }    from '@angular/platform-browser-dynamic';
import { AppComponent } from './app.component';
import {ROUTER_PROVIDERS} from "@angular/router"
bootstrap(AppComponent,[ROUTER_PROVIDERS]);

6. Open app.components.ts

import the following libraries:
import {DefaultComponent} from "./default.component";
import {ROUTER_DIRECTIVES,Routes,Router} from "@angular/router";
import {OnInit} from '@angular/core';

Modify the template to:
template: `
<br />
<h1>
THIS IS AN EXAMPLE</h1>
<br />
<br />
<a default="" href="#" routerlink="">Default</a><br />
<a firstexample="" href="#" routerlink="">First Example</a><br />
<br />
<div>
<br />
<router-outlet></router-outlet><br />
</div>
<br />
`,

Set directives as:
directives:[DefaultComponent, FirstExampleComponent, ROUTER_DIRECTIVES]

Add a Route Decorator as
@Routes([
{path:'/default', component:DefaultComponent},
{path:'/firstExample', component:FirstExampleComponent}
])

Modify AppComponent class to:

export class AppComponent implements OnInit{
constructor(private router: Router) {}

ngOnInit() {
    this.router.navigate(['/default']);
}

}

The file should be like:
import { Component } from '@angular/core';
import {DefaultComponent} from "./default.component";
import {FirstExampleComponent} from "./first-example.component";
import {ROUTER_DIRECTIVES,Routes,Router} from "@angular/router";
import {OnInit} from '@angular/core';

@Component({
selector: 'my-app',
template:`
<br />
<h1>
THIS IS AN EXAMPLE</h1>
<br />
<br />
<a default="" href="#" routerlink="">Default</a><br />
<a firstexample="" href="#" routerlink="">First Example</a><br />
<br />
<div>
<br />
<router-outlet></router-outlet><br />
</div>
<br />
`,

directives:[DefaultComponent, FirstExampleComponent, ROUTER_DIRECTIVES]
})

@Routes([
{path:'/default', component:DefaultComponent},
{path:'/firstExample', component:FirstExampleComponent}
])
export class AppComponent implements OnInit{
constructor(private router: Router) {}

ngOnInit() {
    this.router.navigate(['/default']);
}

}

7. Finally use Ctrl+Shift+B to compile the code and F5 to run it

Simple Example of Angular2

2016-05-04T14:06:00.000-07:00

Note: If you are using Visual Studio Code, you can use Ctrl + Shift + B to recompile each one of the changes. The change will be automatically displayed on the browser.

1. Create a new ts file with the following content

import {Component} from "@angular/core"
@Component({
selector:"my-app",
template:"Hello there"
})

export class AppComponent{}

2. Lets try the click event

import {Component} from "@angular/core"
@Component({
selector:"my-app",
template:`
<button (click)="sayHello()">Click</button>

`
})

export class AppComponent{
sayHello(){
alert("Hello there !");
}

}

3. Lets try ngFor directive
import {Component} from "@angular/core"
@Component({
selector:"my-app",
template:`
  <button (click)="sayHello()">Click</button>
  <div *ngFor="#person of people" >
{{person.name}}/{{person.phone}}
  </div>

`
})

export class AppComponent{
public people=[{"name":"John Smith","phone":"1234567"},
{"name":"Michael Schumacher","phone":"9876543"},
{"name":"Martin McFly","phone":"443322111"}]
sayHello(){
alert("Hello there !");
}

}

4. Lets add a click event per each one of the divs
import {Component} from "@angular/core"
@Component({
selector:"my-app",
template:`
  <button (click)="sayHello()">Click</button>
  <div *ngFor="#person of people" (click)="sayHello()">
{{person.name}}/{{person.phone}}
  </div>

`
})

export class AppComponent{
public people=[{"name":"John Smith","phone":"1234567"},
{"name":"Michael Schumacher","phone":"9876543"},
{"name":"Martin McFly","phone":"443322111"}]
sayHello(){
alert("Hello there !");
}

}

5.We can add edition per each one of the rows
import {Component} from "@angular/core"
@Component({
selector:"my-app",
template:`
  <button (click)="sayHello()">Click</button>
  <div *ngFor="#person of people" (click)="selectRow(person)">
{{person.name}}/{{person.phone}}
  </div>
  <input type="text" [(ngModel)]="selectedPerson.name"/>
  <input type="text" [(ngModel)]="selectedPerson.phone"/>
`
})

export class AppComponent{
public selectedPerson={};
public people=[{"name":"John Smith","phone":"1234567"},
{"name":"Michael Schumacher","phone":"9876543"},
{"name":"Martin McFly","phone":"443322111"}]
sayHello(){
alert("Hello there !");
}
selectRow(person){
this.selectedPerson=person;
}

}

6. Now lets delete an element
import {Component} from "@angular/core"
@Component({
selector:"my-app",
template:`

  <div *ngFor="let person of people" (click)="selectRow(person)">
{{person.name}}/{{person.phone}}
  <button (click)="deleteRow(person)">Delete</button>
  </div>
  <input type="text" [(ngModel)]="selectedPerson.name"/>
  <input type="text" [(ngModel)]="selectedPerson.phone"/>

`
})

export class AppComponent{
public selectedPerson={};
public people=[{"name":"John Smith","phone":"1234567"},
{"name":"Michael Schumacher","phone":"9876543"},
{"name":"Martin McFly","phone":"443322111"}]
sayHello(){
alert("Hello there !");
}
selectRow(person){
this.selectedPerson=person;
}

deleteRow(person){
this.people.splice(this.people.indexOf(person),1);
}
}

7. Lets add a new record
import {Component} from "@angular/core"
@Component({
selector:"my-app",
template:`

  <div *ngFor="let person of people" (click)="selectRow(person)">
{{person.name}}/{{person.phone}}
  <button (click)="deleteRow(person)">Delete</button>
  </div>
  <input type="text" [(ngModel)]="selectedPerson.name"/>
  <input type="text" [(ngModel)]="selectedPerson.phone"/>
  <button (click)="addPerson()">Add Person
>      `
})

export class AppComponent{
public selectedPerson={};
public people=[{"name":"John Smith","phone":"1234567"},
{"name":"Michael Schumacher","phone":"9876543"},
{"name":"Martin McFly","phone":"443322111"}]
sayHello(){
alert("Hello there !");
}
selectRow(person){
this.selectedPerson=person;
}

deleteRow(person){
this.people.splice(this.people.indexOf(person),1);
}

addPerson(){
this.people.push(this.selectedPerson);
}
}

Setup of Environment with VS Code for Angular 2

2016-05-04T06:29:00.000-07:00

1. Download Visual Studio Code from https://code.visualstudio.com/Download

2. Create a new directory named example1

3. Open Visual Studio Code

4. Open the directory with Visual Studio Code

5. Create the files tsconfig.json, typings.json, package.json, index.html,systemjs.config.js in example1 directory

6. Copy the contents of tsconfig.json from https://angular.io/docs/ts/latest/quickstart.html to tsconfig.json

7. Copy the contents of typings.json from https://angular.io/docs/ts/latest/quickstart.html to typings.json

8. Copy the contents of package.json from https://angular.io/docs/ts/latest/quickstart.html to package.json

9. Copy the contents of index.html from https://angular.io/docs/ts/latest/quickstart.html to index.html

10. Copy the contents of systemjs.config.js from https://angular.io/docs/ts/latest/quickstart.html to systemjs.config.js

11. Create a directory named app in example1

12. Create a file named app.component.ts with the following content or copy it from https://angular.io/docs/ts/latest/quickstart.html

import { Component } from '@angular/core';

@Component({
selector: 'my-app',
template: '<h1>Angular 2 Example with VS Code</h1>'
})
export class AppComponent { }

13. Create main.ts with the following content or copy it from https://angular.io/docs/ts/latest/quickstart.html

import { bootstrap } from '@angular/platform-browser-dynamic';
import { AppComponent } from './app.component';
bootstrap(AppComponent);

14. Save all your files

15. On Visual Studio Code click on Debug

16. Click on the Gear

17. Select Node.js as environment

18. Open View/Command Palette

19. Type Tasks: Configure Task Runner

20. Select TypeScript - tsconfig.json

21. Open a terminal or console and go into to the example directory

22. execute the command npm install

23. Open .vscode/launch.json

24. search for program into configurations

25. change the value to
"program": "${workspaceRoot}/node_modules/lite-server/bin/lite-server",

Note: you may need to run npm install -g typescript to execute typescript commands.

26. Open View/Command Palette

27: Type Task: Run Task

28. Select tsc

28: Run F5 to run the application

Creating a Simple Angular 2 Example

2016-03-16T23:27:00.002-07:00

1. Create a simple template(Download a template of angular2 with gulp from https://github.com/santiago762000/angular-2-env-setup)
2. run npm install to install all the required libraries
3. run npm start to start the service. It will open a browser window to test the application
4. open another window
5. run gulp
6. create a new file named first-example.component.ts
7. import the component library
    import {Component} from "angular/core"
8. Add a decorator
@Component({
selector:'myTag',
template:'This is a test'
})
9. Add a component class
export class FirstExampleComponent{
}
first-example.component.ts should be like:
import {Component} from "angular2/core"

@Component({
selector:'myTag',
template:'This is a test'
})
export class FirstExampleComponent{

}

10. Open dev/app.components.ts
11. Import FirstExample.component.ts
import {FirstExampleComponent} from "./first-example.component";

12. Add the directives property to @Component with an array of Components that will be used for app.components.ts
directives:[FirstExampleComponent]

13. Modify the template property to show tag
template: '',

app.component.ts should look like:
import {Component} from 'angular2/core';
import {FirstExampleComponent} from "./first-example.component";
@Component({
    selector: 'my-app',
    template: '',
    directives:[FirstExampleComponent]
})
export class AppComponent {
}
14. Check the opened browser on step 3:
http://localhost:3000/

Using AngularJS to Load Some Photos from Flickr

2014-09-20T07:47:00.000-07:00

For the following example we are going to review an easy example of AngularJS to consume
a Json String from Flickr.
We can summarise the process as:
A. Create an HMTL file with ng-directives
B. Use $http to connect to read data from a external server
C. Populate a HTML select element with data
D. Display an image from Flickr
For this example you may use Netbeans 8.01

1.Create a new HTML5 project named AJSFlickr and click on Finish

2. Add the following HTML to create the following GUI
<html>
<head>
<title>AJS Example</title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body>
<div>
Image description:<input type="text">
<button>Search</button><br/>
<select>
<option>select an option</option>
</select><br/>
<img src="" alt=""/>
</div>
</body>
</html>

3. Lets add angularjs script to the previous code and add the following angularjs directives
data-ng-app:to initialise a AngularJS application
data-ng-model:to bind the HTML elements to dynamic data
data-ng-controller:to create a controller for the elements in the div.
data-ng-click: to perform a click on a button
data-ng-selected:to select an image from the select html element
data-ng-options:to add options for a select

<html data-ng-app="myAJSApp">
<head>
<title>AJS Example</title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body>
<div data-ng-controller="AJSFlickrController">
Image description:<input type="text" data-ng-model="description">
<button data-ng-click="searchImage()">Search</button><br/>
<select data-ng-model="selectedImage" data-ng-options="image.title for image in images.photos.photo track by image.id">
<option>select an option</option>
</select><br/>
<img src="https://farm{{selectedImage.farm}}.staticflickr.com/{{selectedImage.server}}/{{selectedImage.id}}_{{selectedImage.secret}}.jpg" alt=""/>
</div>
<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.2.15/angular.min.js"></script>
<script src="myAJSApp.js"></script>
<script src="AJSFlickrController.js"></script>
</body>
</html>

4. Create a javascript file named myAJSApp.js
5. Create a javascript file named AJSFlickrController.js
6. Add the following code to myAJSApp.js to create a module to create a readable application
var app = angular.module("myAJSApp", []);

7. Add the following code to AJSFlickrController.js to use the text entered in the text element and call a function to retrieve the data from
Flickr and populate the select element.

app.config(function ($httpProvider) {
$httpProvider.defaults.useXDomain = true;
delete $httpProvider.defaults.headers.common['X-Requested-With'];
});

app.controller("AJSFlickrController", function ($scope, $http) {
$scope.searchImage = function () {
$http
.get('https://api.flickr.com/services/rest', {
params: {
method: "flickr.photos.search",
api_key: "699982303118892e296bd349c4cc536e",
text: $scope.description,
format: "json"
}
})
.success(function (response, status) {
$scope.images = parseFlickrJson(response);
});
};
});

function parseFlickrJson(jsonstring) {
var data = null;
var jsonFlickrApi = function (d) {
data = d;
}
eval(jsonstring);
return data;
}

8. Open the page in a browser

Creating a simple MVC App with Spring 4.0 and WebMvcConfigurerAdapter

2014-07-18T21:30:00.001-07:00

1. Download STS(Spring Tool Suite) from http://spring.io/tools/sts

2. Create a new Spring Starter Project

3. Check the Web Options and enter a group(org.demo), artefact(exampleweb), and package name(org.demo.exampleweb).

4. Add the following dependences to pom.xml
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<version>7.0.54</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>

Note: you may add the dependencies with the use of the Dependeces tab such as

For tomcat-embed-jasper:

For jstl

5. Add ViewResolver properties to application.properties in the src/main/resources directory
##View Resolver Configuration
spring.view.prefix=/WEB-INF/jsp
spring.view.suffix=.jsp

6. Create the following directories in your projects

7. Add a new jsp page named home.jsp. Use the following code for the JSP page
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>

This is an example

8. Create a new class named MVCConfiguration in the package org.demo.exampleweb.config
and extend WebMvcConfigurerAdapter class

9. Override addViewControllers(ViewControllerRegistry registry) and add the following code

package org.demo.exampleweb.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@Configuration
public class MVCConfiguration extends WebMvcConfigurerAdapter {

@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("home");
}

}

10. Run your App with Spring Boot App

11. Open a browser and enter localhost:8080 as URL

Creating a simple MVC App with Spring 4.0 and Controller Annotation

2014-07-18T21:22:00.002-07:00

1. Download STS(Spring Tool Suite) from http://spring.io/tools/sts

2. Create a new Spring Starter Project

3. Check the Web Options and enter a group(org.demo), artefact(exampleweb), and package name(org.demo.exampleweb).

4. Add the following dependences to pom.xml
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<version>7.0.54</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>

Note: you may add the dependencies with the use of the Dependeces tab such as

For tomcat-embed-jasper:

For jstl

5. Add ViewResolver properties to application.properties in the src/main/resources directory
##View Resolver Configuration
spring.view.prefix=/WEB-INF/jsp
spring.view.suffix=.jsp

6. Create the following directories in your projects

7. Add a new jsp page named home.jsp. Use the following code for the JSP page
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>

This is an example

8.Create a new class named RootController in the package org.demo.exampleweb.controllers

9. Add the following code

package org.demo.exampleweb.controllers;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RootController {
@RequestMapping("/")
public String showHomePage(){
return "home";
}
}

10. Run your App with Spring Boot App

11. Open a browser and enter localhost:8080 as URL

Spring MVC 3.0 y Maven

2012-02-23T17:24:00.004-08:00

For this example I'm using MacBook Pro with Mac OS x 10.7.2, SpringSource Tool Suite 2.8.1 and Maven 2.0

First of all, we have to create a maven project.

Next check the first checkbox to avoid creating the application with a archetype.

The code of the file pom.xml is the following(Notice that I added dependencies and plugins to deploy the app on Jetty)
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example.web</groupId>
    <artifactId>SF</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <build>
        <finalName>AplicacionWeb</finalName>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

Next you have to run eclipse:eclipse to run the project and download the libraries to your project.

After this, you have to refresh the project.

Next, create the package com.example.model.
Into this package you have to create the a Java class named Product. This class should implements Serializable. Also, it contains the following code:

package com.example.model;

import java.io.Serializable;

public class Product implements Serializable{
    private static final long serialVersionUID = 1L;
    private String name;
    private Double price;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
}

Next, create a package named com.example.service
Into this package create an interface named ProductService.
This interface have two functions.
ListgetAllProducts()       -- To retrieve all the products
void addProduct(Product product) -- To add a product.

This is the code of the ProductService:
package com.example.service;

package com.example.service;

import java.util.List;

import com.example.model.Product;

public interface ProductService {
    List<Product> getAllProducts();
    void addProduct(Product product);
}

The we have to implement the Interface, hence we create a new package named com.example.impl This package will contain a class named ProductServiceImpl. This is a service class, so it implements the @Service annotation. This is the code for ProductServiceImpl.java

package com.example.impl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.stereotype.Service;

import com.example.model.Product;
import com.example.service.ProductService;
@Service
public class ProductServiceImpl implements ProductService {
    List products=new ArrayList();

    public List getAllProducts() {
        return products;
    }

    public void addProduct(Product product) {
        products.add(product);
    }
}

Next, we have to create the controller.
Create a package named com.example.controller. Into this package you have to create a Class named ProductController:
package com.example.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import com.example.model.Product;
import com.example.service.ProductService;

@Controller
@RequestMapping(value="product")// This is also the path of the URL after the App
public class ProductController {
    @Autowired
    private ProductService productService;

    /*
     * When a link from the app calls viewAllProducts this function is called.
     * Also the list object is updated with the use of the function addObject and
     * the variable products
     */
    @RequestMapping(value="listProducts",method=RequestMethod.GET)
    public ModelAndView viewAll(){
        ModelAndView mav=new ModelAndView();
        mav.setViewName("list");//The name of the JSP page
        mav.addObject("products",productService.getAllProducts());
        return mav;
    }

    /*
     * When a link from the app calls newProduct this function is called.
     * Also the product is added to the current list of products. Also a new empty
     * instance of the object is created.
     */
    @RequestMapping(value="newProduct",method=RequestMethod.GET)
    public ModelAndView newproduct(){
        ModelAndView mav=new ModelAndView();
        mav.setViewName("new");//The name of the JSP page
        mav.addObject("product",new Product());
        return mav;
    }

    /*
     * When a link from the app calls newProduct this function is called.
     * Also the product is added to the current list of products. Also a new empty
     * instance of the object is created.
     */
    @RequestMapping(value="addProduct",method=RequestMethod.POST)
    public String add(@ModelAttribute(value="product") Product product){
        productService.addProduct(product);
        return "redirect:listProducts.htm";
    }
}

After this, we have to create the following route of directories webapp/WEB-INF/jsp into src/main.
Into webapp/WEB-INF we have to create two xml files web.xml and dispatcher-servlet.xml.
web.xml will be configurated to support the Servlet for the use of Springfrmework also its mapping.
This is code for web.xml:
<?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">     <servlet>         <servlet-name>dispatcher</servlet-name>         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>              </servlet>     <servlet-mapping>         <servlet-name>dispatcher</servlet-name>         <url-pattern>*.htm</url-pattern>     </servlet-mapping>     <welcome-file-list>         <welcome-file>index.jsp</welcome-file>     </welcome-file-list> </web-app>

The file dispatcher-server.xml has the springframework configuration to locate the implementation of the services and controllers. Also it is used to specify the directories where the jsp are stored.
This is the source code of dispatcher-server.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
                             http://www.springframework.org/schema/beans/spring-beans.xsd
                             http://www.springframework.org/schema/context
                             http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.example.controller"/>
<context:component-scan base-package="com.example.impl"/>
<context:annotation-config />
<bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
          <property name="prefix"><value>/WEB-INF/jsp/</value></property>
          <property name="suffix"><value>.jsp</value></property>
          </bean>
</beans>

Next, we have to create the JSP pages into webapp/WEB-INF/jsp.

The information will be displayed with the help of SpringFramework JSTL.
Next, we have to create a JSP named index.jsp to redirect the app to the list of products. So that, create a page named index.jsp at webapp directory with the following code:
<jsp:forward page="product/listProducts.htm"></jsp:forward>

Create a JSP page named as include.jsp. This page will be used to save the calls to the JSTL libraries. This is the code for include.jsp:
<%@page isELIgnored="false" %> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>

Next, create a JSP named list.jsp
This page will display the information of the products in memory.<%@ include file="include.jsp"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Product List</title>
</head>
<body>
<table>
<tr>
<td>Product Name</td>
<td>Price</td>
</tr>
<c:forEach items="${products}" var="product">
<tr>
<td>${product.name}</td>
<td>${product.price}</td>
</tr>
</c:forEach>
</table>
<a href="/SF/product/newProduct.htm">Add New Product</a>
</body>
</html>

Also, create a page named new.jsp This page will add a product to the current list in memory.
<%@ include file="include.jsp"%>
<%@taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>New Product</title>
</head>
<body>
<form:form action="addProduct.htm" method="post" commandName="product">
Product Name:<form:input path="name"/>
Price:<form:input path="price"/>
<input type="submit" value="add"/>
</form:form>
</body>
</html>
Run the app with mvn jetty:run

Finally open an Internet browser at http://localhost:8080/SF

Jtwitter

2012-01-24T21:38:00.000-08:00

For this example I'm using a MacBook Pro with Lion, Netbeans and JDK1.6

First of all you have to create a Twitter app, hence you have to go to dev.twitter.com and log in with your twitter account

Next create a new application with the details related to your app.

Then click on setting and change the Application Type to Read, Write and Access direct messages

Then click on update this twitter application's settings

Create my Access tokens

First of all you need the following libraries
common-codec-1.4.jar http://mirrors.ibiblio.org/pub/mirrors/maven2/commons-codec/commons-codec/1.4/commons-codec-1.4.jar
jtwitter.jar http://www.winterwell.com/software/jtwitter/jtwitter.jar
sign-core-1.2.1.1.jar http://code.google.com/p/oauth-signpost/downloads/detail?name=signpost-core-1.2.1.1.jar

Next create a Web application with Netbeans

In the index.jsp set the following code.
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <form name="form1" action="NewServlet" method="Post">
        User:<input type="textfield" name="user"/><br/>
        Message:<input type="textfield" name="message"/><br/>
        <input type="submit" value="Enviar"/>
        </form>
    </body>
</html>

Next create a Servlet. You may call it NewServlet
with the following code:

package com.ejemplo;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import winterwell.jtwitter.OAuthSignpostClient;
import winterwell.jtwitter.Twitter;

public class NewServlet extends HttpServlet {
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String JTWITTER_OAUTH_KEY = "xxxxxxxxxxxxxxxxxxxxxxxxx";
        String JTWITTER_OAUTH_SECRET = "XXXXXXXXXXXXXXXXXX";
        String JTWITTER_ACCESS_TOKEN = "yyyyyyyyyyyyyyyyyyyyyyyyyy";
        String JTWITTER_ACCESS_TOKEN_SECRET = "YYYYYYYYYYYYYYY";
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            out.println("Your Message was sent");
            OAuthSignpostClient oauthClient = new OAuthSignpostClient(JTWITTER_OAUTH_KEY, JTWITTER_OAUTH_SECRET, JTWITTER_ACCESS_TOKEN, JTWITTER_ACCESS_TOKEN_SECRET);
            Twitter twitter = new Twitter(request.getParameter("user"), oauthClient);
            String fecha = (new Date()).toString();
            twitter.updateStatus(request.getParameter("message") + fecha);
        } catch (Exception ex) {
            out.println(ex.getMessage());
            ex.printStackTrace();
        } finally {
            out.close();
        }
    }

    //
    /**
     * Handles the HTTP GET method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Handles the HTTP POST method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Returns a short description of the servlet.
     * @return a String containing servlet description
     */
    @Override
    public String getServletInfo() {
        return "Short description";
    }//
}

Replace xxxxx with Consumer key
Replace XXXX with Consumer secret
Replace yyyyy with Access token
Replace YYYY with Access token secret

Finally upload you application to a webserver and run the app

An example of Weka and Java Persistence API

2011-11-22T21:38:00.001-08:00

For this example I'm using MacBook Pro with Lion, Netbeans 6.9, MySQL Database.
First of all, we have to create a database in MySQL to retrieve the data. You can use the following script:

CREATE DATABASE IF NOT EXISTS exampleWeka;
USE exampleWeka;
DROP TABLE IF EXISTS weather;
CREATE TABLE weather (
    id INT NOT NULL AUTO_INCREMENT, PRIMARY KEY(id),
    outlook varchar(10),
    temperature varchar(10),
    humidity varchar(10),
    windy varchar(10),
    play varchar(10)
);
insert into weather(outlook,temperature,humidity,windy,play)values('sunny','hot','high','FALSE','no');
insert into weather(outlook,temperature,humidity,windy,play)values('sunny','hot','high','TRUE','no');
insert into weather(outlook,temperature,humidity,windy,play)values('overcast','hot','high','FALSE','yes');
insert into weather(outlook,temperature,humidity,windy,play)values('rainy','mild','high','FALSE','yes');
insert into weather(outlook,temperature,humidity,windy,play)values('rainy','cool','normal','FALSE','yes');
insert into weather(outlook,temperature,humidity,windy,play)values('rainy','cool','normal','TRUE','no');
insert into weather(outlook,temperature,humidity,windy,play)values('overcast','cool','normal','TRUE','yes');
insert into weather(outlook,temperature,humidity,windy,play)values('sunny','mild','high','FALSE','no');
insert into weather(outlook,temperature,humidity,windy,play)values('sunny','cool','normal','FALSE','yes');
insert into weather(outlook,temperature,humidity,windy,play)values('rainy','mild','normal','FALSE','yes');
insert into weather(outlook,temperature,humidity,windy,play)values('sunny','mild','normal','TRUE','yes');
insert into weather(outlook,temperature,humidity,windy,play)values('overcast','mild','high','TRUE','yes');
insert into weather(outlook,temperature,humidity,windy,play)values('overcast','hot','normal','FALSE','yes');
insert into weather(outlook,temperature,humidity,windy,play)values('rainy','mild','high','TRUE','no');
commit;

Then you can download Weka. I downloaded the version 3.4.19 from http://sourceforge.net/projects/weka/files/weka-3-4/3.4.19/weka-3-4-19.zip/download. Then you have to extract the file and add weka.jar to the libraries of your EJB project

Then you have to create an Enterprise Application project in Netbeans.

Add MySQL library to the EJB Project.

Add the library weka.jar to the EJB project. I'm using the version available at:http://sourceforge.net/projects/weka/files/weka-3-7/3.7.5/weka-3-7-5-monolithic.jar/download

After this, create a Datasource to the database created above.

Create an Entity class to use the weather table.

Create a Session bean with remote interface.

Create the following utility class in the package com.example.ejb.util of the EJB project

package com.example.ejb.util;

import com.example.ejb.entity.Weather;
import java.util.List;
import weka.classifiers.trees.J48;
import weka.core.Attribute;
import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances;

public class UtilWeka {
    static Instances instances = null;

    private static FastVector createAttributes(boolean classification) {
        FastVector fvWekaAttributes = new FastVector(9);
        FastVector fvOutlook = new FastVector(3);
        fvOutlook.addElement("sunny");
        fvOutlook.addElement("overcast");
        fvOutlook.addElement("rainy");
        Attribute outlook = new Attribute("outlook", fvOutlook);
        fvWekaAttributes.addElement(outlook);

        FastVector fvTemperature = new FastVector(3);
        fvTemperature.addElement("hot");
        fvTemperature.addElement("mild");
        fvTemperature.addElement("cool");
        Attribute temperature = new Attribute("temperature", fvTemperature);
        fvWekaAttributes.addElement(temperature);

        FastVector fvHumidity = new FastVector(2);
        fvHumidity.addElement("high");
        fvHumidity.addElement("normal");
        Attribute humidity = new Attribute("humidity", fvHumidity);
        fvWekaAttributes.addElement(humidity);

        FastVector fvWindy = new FastVector(2);
        fvWindy.addElement("TRUE");
        fvWindy.addElement("FALSE");
        Attribute windy = new Attribute("windy", fvWindy);
        fvWekaAttributes.addElement(windy);

        if(!classification){
        FastVector fvPlay = new FastVector(2);
        fvPlay.addElement("no");
        fvPlay.addElement("yes");
        Attribute play = new Attribute("play", fvPlay);
        fvWekaAttributes.addElement(play);
        }

        return fvWekaAttributes;
    }

    private static Instances generateInstances(List list) {
        FastVector fvAttributes = createAttributes(false);
        Instances instances = new Instances("Rel", fvAttributes, 5);
        instances.setClassIndex(instances.numAttributes() - 1);
        for (Weather weather : list) {
            Instance iExample = new Instance(5);
            iExample.setValue((Attribute) fvAttributes.elementAt(0), weather.getOutlook());
            iExample.setValue((Attribute) fvAttributes.elementAt(1), weather.getTemperature());
            iExample.setValue((Attribute) fvAttributes.elementAt(2), weather.getHumidity());
            iExample.setValue((Attribute) fvAttributes.elementAt(3), weather.getWindy());
            iExample.setValue((Attribute) fvAttributes.elementAt(4), weather.getPlay());
            instances.add(iExample);
        }
        return instances;
    }

    private static Instance generateWeatherInstance(Weather weather) {
        FastVector fvAttributes = createAttributes(true);
        Instances instances = new Instances("Rel", fvAttributes, 9);
        instances.setClassIndex(instances.numAttributes() - 1);

        Instance iExample = new Instance(9);
        iExample.setValue((Attribute) fvAttributes.elementAt(0), weather.getOutlook());
        iExample.setValue((Attribute) fvAttributes.elementAt(1), weather.getTemperature());
        iExample.setValue((Attribute) fvAttributes.elementAt(2), weather.getHumidity());
        iExample.setValue((Attribute) fvAttributes.elementAt(3), weather.getWindy());
       // iExample.setValue((Attribute) fvAttributes.elementAt(4), weather.getPlay());

        instances.add(iExample);

        return instances.firstInstance();
    }

    public static void initJ48Tree(List list) {
        instances=generateInstances(list);
        try {
            J48 j48 = new J48();
            instances.setClassIndex(instances.numAttributes() - 1);
            j48.buildClassifier(instances);
            System.out.println(j48.toString());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static void classifyInstanceJ48(Weather weather) {
        double val=0;
        try {
            J48 j48 = new J48();
            instances.setClassIndex(instances.numAttributes() - 1);
            j48.buildClassifier(instances);
            val=j48.classifyInstance(generateWeatherInstance(weather));
            if(val==1){
                System.out.println("We can play");
            }else{
                System.out.println("We can't play");
            }

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

Change SessionBean to:

package com.example.ejb.session;

import com.example.ejb.entity.Weather;
import com.example.ejb.util.UtilWeka;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import weka.core.Instances;

@Stateless
public class SessionBean implements SessionBeanRemote {

    @PersistenceContext
EntityManager em;
Instances instances =null;
    public void initWeatherData() {
        Query query=em.createNamedQuery("Weather.findAll");
        UtilWeka.initJ48Tree((List)query.getResultList());
}

    public void classifyJ48(Weather weather) {
        UtilWeka.classifyInstanceJ48(weather);
    }

}

Modify the client with an injection to the Session Bean.

package mavenwekaapp;

import com.example.ejb.entity.Weather;
import com.example.ejb.session.SessionBeanRemote;
import javax.ejb.EJB;

public class Main {
    @EJB
    private static SessionBeanRemote sessionBean;

    public static void main(String[] args) {
        sessionBean.initWeatherData();
        Weather wheater=new Weather();
        wheater.setHumidity("normal");
        wheater.setOutlook("overcast");
        wheater.setTemperature("hot");
        wheater.setWindy("FALSE");
        sessionBean.classifyJ48(wheater);
    }
}

Run the Enterprise Project.

These are functions,which implement ID3 and NBTree algorithms.
public static void initId3Tree(List list) {
        instances=generateInstances(list);
        try {
            Id3 id3 = new Id3();
            instances.setClassIndex(instances.numAttributes() - 1);
            id3.buildClassifier(instances);
            System.out.println(id3.toString());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static void classifyInstanceId3(Weather weather) {
        double val=0;
        try {
            Id3 id3 = new Id3();
            instances.setClassIndex(instances.numAttributes() - 1);
            id3.buildClassifier(instances);
            val=id3.classifyInstance(generateWeatherInstance(weather));
            if(val==1){
                System.out.println("We can play");
            }else{
                System.out.println("We can't play");
            }

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static void initNBTree(List list) {
        instances=generateInstances(list);
        try {
            NBTree nbTree = new NBTree();
            instances.setClassIndex(instances.numAttributes() - 1);
            nbTree.buildClassifier(instances);
            System.out.println(nbTree.toString());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static void classifyInstanceNBTree(Weather weather) {
        double val=0;
        try {
            NBTree nbTree = new NBTree();
            instances.setClassIndex(instances.numAttributes() - 1);
            nbTree.buildClassifier(instances);
            val=nbTree.classifyInstance(generateWeatherInstance(weather));
            if(val==1){
                System.out.println("We can play");
            }else{
                System.out.println("We can't play");
            }

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

How to use Facebook Graph API with Javascript

2011-11-17T20:27:00.000-08:00

For this example I'm using: MacBook Pro with Lion(10.7.1) as operative system, Netbeans 7.0 and a Facebook account.

This is a quick example of Facebook Graph API. This code allows Facebook users to publish information in their walls, retrieve friends and send message to their friends. To test this code you have to create a Facebook application in https://developers.facebook.com/apps

I named the application as TestGraphAPI:

Enter the captcha value:

Then you have to register the URL of your application, pg: http://localhost:8080/TestGraphAPI.

I created a web java application in Netbeans and pasted the following code in the index jsp page:

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Facebook Example</title>
    </head>
    <body>
        <div id="fb-root">
            <script type="text/javascript">

                window.fbAsyncInit = function() {
                    FB.init({appId: 'XXXXXXXXXXXXXXX', status: true, cookie: true, xfbml: true});
                    FB.getLoginStatus(function(response) {
                        if (response.session!=null) {
                            alert("Welcome, you have been logged to Facebook");
                        }else{
                            alert("To use this application you have to be logged at Facebook");

                        }
                    });
                };
                (function() {
                    var scriptFacebook = document.createElement('script');
                    scriptFacebook.type = 'text/javascript';
                    scriptFacebook.src = document.location.protocol +
                        '//connect.facebook.net/en_US/all.js';
                    scriptFacebook.async = true;
                    document.getElementById('fb-root').appendChild(scriptFacebook);
                }());

                function obtenerAmigos(){
                    document.getElementById("imagenes").innerHTML="Click on the images to send a message<br/>";
                    FB.api('/me/friends',function(response){
                        for(i=0;i<response.data.length;i++){
                            document.getElementById("imagenes").innerHTML+="<img src='https://graph.facebook.com/"+response.data[i].id+"/picture' onclick='enviarMensaje(\""+response.data[i].id+"\",\""+response.data[i].name+"\")'/>";
                        }
                    });
                }

                function escribirMuro(){
                    var mensaje=prompt("What is your message?");
                    FB.api('/me/feed', 'post', { message: mensaje }, function(response) {
                        if (!response || response.error) {
                            alert('A problem ocurred');
                        } else {
                            alert('The message was sent to your wall');
                        }

                    });
                }

                function enviarMensaje(id,name){
                    var mensaje=prompt("Enter the message to "+name);
                    FB.api('/'+id+'/feed', 'POST', { message: mensaje }, function(response) {
                        if (!response || response.error) {
                            alert('A problem ocurred');
                        } else {
                            alert('The message was sent to '+name);
                        }
                    });

                }

            </script>
        </div>
    <fb:login-button autologoutlink="true" scope="email,status_update,publish_stream,sms"></fb:login-button><br/>
    <input type="button" value="Post on your wall" onclick="escribirMuro()"/>
    <input type="button" value="Get Friends" onclick="obtenerAmigos()"><br/>
    <div id="fb-root">
        <div id="imagenes">

        </div>
    </div>
</body>
</html>

Finally replace the APP ID in XXXXXXXXXXXXXXX

and test the application.

Bridge Struts to Portlet

2011-06-28T10:17:00.001-07:00

For this example I'm using Eclipse Helios, Liferay 6.06 and Ubuntu(Also, you may use Netbeans 7.0 for the Struts Project).

First of all, you need a Struts proyect. I created a project with the following tutorial:http://netbeans.org/kb/docs/web/quickstart-webapps-struts.html.
Also, I uploaded this project at http://www.megaupload.com/?d=9EJND8KQ

Download the project.
Extract it.

Now, we have to create a new Portlet App with Eclipse.

Replace the content of src directory of your Portlet project with the directory src/java content of MyStrutsApp.

Copy the libraries of WEB-INF/lib with the libraries of MyStrutsApp/build/web/WEB-INF/lib

Delete commons-logging-1.0.4.jar, standard-1.0.2 and jstl-1.0.2

Next, copy struts tld files to WEB-INF/tld directory of your Portlet Project.
You may download the tld files from:http://www.megaupload.com/?d=TFVCGMM2

Also, copy struts-config.xml,tiles-defs.xml,validation.xml,validator-rules.xml from MyStrutsApp/web/WEB-INF to WEB-INF/ of your Portlet Project

Next, copy the files index.jsp, login.jsp, success.jsp of /MyStrutsApp/web in Bridge-portlet/docroot

After that, copy the libraries jstl.jar and standard.jar to Bridge-portlet/docroot/WEB-INF/lib. The libraries are uploaded in:http://www.megaupload.com/?d=MWJ0BFRQ

And refresh your Eclipse project.

Next open liferay-plugin-package.properties. Click source. Replace the code with the following code:
name=Bridge
module-group-id=liferay
module-incremental-version=1
tags=
short-description=
change-log=
page-url=http://www.liferay.com
author=Liferay, Inc.
licenses=LGPL

portal-dependency-jars=\
antlr.jar,\
commons-beanutils.jar,\
commons-collections.jar,\
commons-digester.jar,\
commons-fileupload.jar,\
commons-io.jar,\
commons-lang.jar,\
commons-validator.jar,\
jcommon.jar,\
jfreechart.jar,\
oro.jar,\
portals-bridges.jar,\
struts.jar

portal-dependency-tlds=\
struts-bean.tld,\
struts-bean-el.tld,\
struts-html.tld,\
struts-html-el.tld,\
struts-logic.tld,\
struts-logic-el.tld,\
struts-nested.tld,\
struts-tiles.tld,\
struts-tiles-el.tld

Replace liferay-portlet.xml with the following code:

<?xml version="1.0"?>
<!DOCTYPE liferay-portlet-app PUBLIC "-//Liferay//DTD Portlet Application 6.0.0//EN" "http://www.liferay.com/dtd/liferay-portlet-app_6_0_0.dtd">

<liferay-portlet-app>

<portlet>
<portlet-name>Bridge</portlet-name>
<portlet-url-class>com.liferay.portal.apache.bridges.struts.LiferayStrutsPortletURLImpl</portlet-url-class>
<use-default-template>true</use-default-template>
<restore-current-view>true</restore-current-view>
</portlet>
<role-mapper>
<role-name>administrator</role-name>
<role-link>Administrator</role-link>
</role-mapper>
<role-mapper>
<role-name>guest</role-name>
<role-link>Guest</role-link>
</role-mapper>
<role-mapper>
<role-name>power-user</role-name>
<role-link>Power User</role-link>
</role-mapper>
<role-mapper>
<role-name>user</role-name>
<role-link>User</role-link>
</role-mapper>
</liferay-portlet-app>

After that, change portlet.xml to:
<?xml version="1.0"?>

<portlet-app
version="2.0"
xmlns="http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd"
>

<portlet>
<portlet-name>Bridge</portlet-name>
<display-name>Bridge Sample</display-name>
<portlet-class>org.apache.portals.bridges.struts.StrutsPortlet</portlet-class>
<init-param>
<name>ServletContextProvider</name>
<value>com.liferay.util.bridges.struts.LiferayServletContextProviderWrapper</value>
</init-param>
<init-param>
<name>ViewPage</name>
<value>/portlet_action/login</value>
</init-param>
<expiration-cache>0</expiration-cache>
<supports>
<mime-type>text/html</mime-type>
<portlet-mode>VIEW</portlet-mode>
</supports>
<portlet-info>
<title>Bridge</title>
<short-title>NewPortlet</short-title>
<keywords></keywords>
</portlet-info>
<security-role-ref>
<role-name>administrator</role-name>
</security-role-ref>
<security-role-ref>
<role-name>guest</role-name>
</security-role-ref>
<security-role-ref>
<role-name>power-user</role-name>
</security-role-ref>
<security-role-ref>
<role-name>user</role-name>
</security-role-ref>
</portlet>
</portlet-app>

Change struts-config.xml to:
<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_3.dtd">

<struts-config>
<form-beans>
<form-bean name="LoginForm" type="com.myapp.struts.LoginForm" />

</form-beans>

<global-exceptions>

</global-exceptions>

<global-forwards>
<forward name="welcome" path="/Welcome.do" />
</global-forwards>

<action-mappings>
<action path="/bridge_struts_portlet/view" forward="portlet.sample_struts_portlet.view" />

<action name="LoginForm" path="/login" scope="request"
type="com.myapp.struts.LoginAction" validate="false">
<forward name="success" path="/success.jsp" />
<forward name="failure" path="/login.jsp" />
</action>
<action path="/Welcome" forward="/welcomeStruts.jsp" />
</action-mappings>

<controller
processorClass="org.apache.portals.bridges.struts.PortletTilesRequestProcessor" />

<message-resources parameter="com/myapp/struts/ApplicationResource" />

<plug-in className="org.apache.struts.tiles.TilesPlugin">
<set-property property="definitions-config" value="/WEB-INF/tiles-defs.xml" />
<set-property property="moduleAware" value="true" />
<set-property property="definitions-parser-validate"
value="true" />
</plug-in>


<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property property="pathnames"
value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml" />
</plug-in>

</struts-config>

Next, change tiles-def.xml to:
<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/tiles-config_1_1.dtd">

<tiles-definitions>
<definition name="portlet.bridge_struts_portlet.view" >
<put name="portlet_content" value="/portlet/bridge_struts_portlet/view.jsp" />
</definition>
</tiles-definitions>

After that, open web.xml. Change the code to:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>Bridge-portlet</display-name>
<servlet>
<servlet-name>PortletActionServlet</servlet-name>
<servlet-class>com.liferay.util.bridges.struts.LiferayPortletServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>PortletActionServlet</servlet-name>
<url-pattern>/portlet_action/*</url-pattern>
</servlet-mapping>
<jsp-config>
<taglib>
<taglib-uri>http://struts.apache.org/tags-bean</taglib-uri>
<taglib-location>/WEB-INF/tld/struts-bean.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>http://portals.apache.org/bridges/struts/tags-portlet-html</taglib-uri>
<taglib-location>/WEB-INF/tld/struts-portlet-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>http://struts.apache.org/tags-logic</taglib-uri>
<taglib-location>/WEB-INF/tld/struts-logic.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>http://struts.apache.org/tags-nested</taglib-uri>
<taglib-location>/WEB-INF/tld/struts-nested.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>http://struts.apache.org/tags-tiles</taglib-uri>
<taglib-location>/WEB-INF/tld/struts-tiles.tld</taglib-location>
</taglib>
</jsp-config>
</web-app>

Now, change the code of login.jsp to:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib uri="http://portals.apache.org/bridges/struts/tags-portlet-html" prefix="html" %>

<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-logic" prefix="logic" %>
<%@ taglib uri="http://struts.apache.org/tags-nested" prefix="nested" %>
<%@ taglib uri="http://struts.apache.org/tags-tiles" prefix="tiles" %>

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<html:form action="/login">
<table border="0">
<tbody>
<tr>
<td colspan="2">
<bean:write name="LoginForm" property="error" filter="false"/>
</td>
</tr>
<tr>
<td><bean:message key="data.name"/></td>
<td><html:text property="name" /></td>
</tr>
<tr>
<td><bean:message key="data.email"/></td>
<td><html:text property="email" /></td>
</tr>
<tr>
<td></td>
<td><html:submit value="Login" /></td>
</tr>
</tbody>
</table>
</html:form>
</body>
</html>

Next, change the code of success.jsp to:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib uri="http://portals.apache.org/bridges/struts/tags-portlet-html" prefix="html" %>
<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-logic" prefix="logic" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Login Success</title>
</head>
<body>
<c:out value="${title}"/>
<h1>Congratulations!</h1>
<p>You have successfully logged in.</p>
<p>Your name is: <bean:write name="LoginForm" property="name" />.</p>
<p>Your email address is: <bean:write name="LoginForm" property="email" />.</p>

<logic:messagesPresent message="true">
<html:messages message="true" id="msg">
<bean:write name="msg" ignore="true"/>
</html:messages>

</logic:messagesPresent>

</body>
</html>

After that, open the file loginAction.java. Set the following code:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.myapp.struts;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.action.ActionMessages;

/**
*
* @author santiago
*/
public class LoginAction extends org.apache.struts.action.Action {

/* forward name="success" path="" */
private static final String SUCCESS = "success";
private final static String FAILURE = "failure";

@Override
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {

// extract user data
LoginForm formBean = (LoginForm)form;
String name = formBean.getName();
String email = formBean.getEmail();

ActionMessages actionMessages = new ActionMessages();
actionMessages.add(ActionMessages.GLOBAL_MESSAGE,
new ActionMessage("errors.cancel"));
saveMessages(request, actionMessages);

// perform validation
if ((name == null) || // name parameter does not exist
email == null || // email parameter does not exist
name.equals("") || // name parameter is empty
email.indexOf("@") == -1) { // email lacks '@'

formBean.setError();
return mapping.findForward(FAILURE);
}
request.setAttribute("title", "This is Test");
return mapping.findForward(SUCCESS);

}

}

Run the project.

The messages don't show in the screen. We have to replace the class MessageTag of apache. To replace the class, you have to create a new package(org.apache.struts.taglib.html) . Into the package create the class named MessagesTag with the following apache struts taglib code:

/*
* $Id: MessagesTag.java 471754 2006-11-06 14:55:09Z husted $
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.struts.taglib.html;

import org.apache.struts.Globals;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.action.ActionMessages;
import org.apache.struts.taglib.TagUtils;
import org.apache.struts.util.MessageResources;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.BodyTagSupport;

import java.util.Iterator;

/**
* Custom tag that iterates the elements of a message collection. It defaults
* to retrieving the messages from <code>Globals.ERROR_KEY</code>, but if the
* message attribute is set to true then the messages will be retrieved from
* <code>Globals.MESSAGE_KEY</code>. This is an alternative to the default
* <code>ErrorsTag</code>.
*
* @version $Rev: 471754 $ $Date: 2005-11-08 23:50:53 -0500 (Tue, 08 Nov 2005)
* $
* @since Struts 1.1
*/
public class MessagesTag extends BodyTagSupport {
/**
* The message resources for this package.
*/
protected static MessageResources messageResources =
MessageResources.getMessageResources(Constants.Package
+ ".LocalStrings");

/**
* Iterator of the elements of this error collection, while we are
* actually running.
*/
protected Iterator iterator = null;

/**
* Whether or not any error messages have been processed.
*/
protected boolean processed = false;

/**
* The name of the scripting variable to be exposed.
*/
protected String id = null;

/**
* The servlet context attribute key for our resources.
*/
protected String bundle = null;

/**
* The session attribute key for our locale.
*/
protected String locale = Globals.LOCALE_KEY;

/**
* The request attribute key for our error messages (if any).
*/
protected String name = Globals.ERROR_KEY;

/**
* The name of the property for which error messages should be returned,
* or <code>null</code> to return all errors.
*/
protected String property = null;

/**
* The message resource key for errors header.
*/
protected String header = null;

/**
* The message resource key for errors footer.
*/
protected String footer = null;

/**
* If this is set to 'true', then the <code>Globals.MESSAGE_KEY</code>
* will be used to retrieve the messages from scope.
*/
protected String message = null;

public String getId() {
return (this.id);
}

public void setId(String id) {
this.id = id;
}

public String getBundle() {
return (this.bundle);
}

public void setBundle(String bundle) {
this.bundle = bundle;
}

public String getLocale() {
return (this.locale);
}

public void setLocale(String locale) {
this.locale = locale;
}

public String getName() {
return (this.name);
}

public void setName(String name) {
this.name = name;
}

public String getProperty() {
return (this.property);
}

public void setProperty(String property) {
this.property = property;
}

public String getHeader() {
return (this.header);
}

public void setHeader(String header) {
this.header = header;
}

public String getFooter() {
return (this.footer);
}

public void setFooter(String footer) {
this.footer = footer;
}

public String getMessage() {
return (this.message);
}

public void setMessage(String message) {
this.message = message;
}

/**
* Construct an iterator for the specified collection, and begin looping
* through the body once per element.
*
* @throws JspException if a JSP exception has occurred
*/
public int doStartTag() throws JspException {
// Initialize for a new request.
processed = false;

// Were any messages specified?
ActionMessages messages = null;

// Make a local copy of the name attribute that we can modify.
String name = this.name;

if ((message != null) && "true".equalsIgnoreCase(message)) {
name = Globals.MESSAGE_KEY;
}

try {
messages =
TagUtils.getInstance().getActionMessages(pageContext, name);
} catch (JspException e) {
TagUtils.getInstance().saveException(pageContext, e);
throw e;
}

// Acquire the collection we are going to iterate over
this.iterator =
(property == null) ? messages.get() : messages.get(property);

// Store the first value and evaluate, or skip the body if none
if (!this.iterator.hasNext()) {
return SKIP_BODY;
}

// process the first message
processMessage((ActionMessage) iterator.next());

if ((header != null) && (header.length() > 0)) {
String headerMessage =
TagUtils.getInstance().message(pageContext, bundle, locale,
header);

if (headerMessage != null) {
TagUtils.getInstance().write(pageContext, headerMessage);
}
}

// Set the processed variable to true so the
// doEndTag() knows processing took place
processed = true;

return (1);
}

/**
* Make the next collection element available and loop, or finish the
* iterations if there are no more elements.
*
* @throws JspException if a JSP exception has occurred
*/
public int doAfterBody() throws JspException {
// Render the output from this iteration to the output stream
if (bodyContent != null) {
TagUtils.getInstance().writePrevious(pageContext,
bodyContent.getString());
bodyContent.clearBody();
}

// Decide whether to iterate or quit
if (iterator.hasNext()) {
processMessage((ActionMessage) iterator.next());

return (1);
} else {
return (SKIP_BODY);
}
}

/**
* Process a message.
*/
private void processMessage(ActionMessage report)
throws JspException {
String msg = null;

if (report.isResource()) {
msg = TagUtils.getInstance().message(pageContext, bundle, locale,
report.getKey(), report.getValues());

if (msg == null) {
String bundleName = (bundle == null) ? "default" : bundle;

msg = messageResources.getMessage("messagesTag.notfound",
report.getKey(), bundleName);
}
} else {
msg = report.getKey();
}

if (msg == null) {
pageContext.removeAttribute(id);
} else {
pageContext.setAttribute(id, msg);
}
}

/**
* Clean up after processing this enumeration.
*
* @throws JspException if a JSP exception has occurred
*/
public int doEndTag() throws JspException {
if (processed && (footer != null) && (footer.length() > 0)) {
String footerMessage =
TagUtils.getInstance().message(pageContext, bundle, locale,
footer);

if (footerMessage != null) {
TagUtils.getInstance().write(pageContext, footerMessage);
}
}

return EVAL_PAGE;
}

/**
* Release all allocated resources.
*/
public void release() {
super.release();
iterator = null;
processed = false;
id = null;
bundle = null;
locale = Globals.LOCALE_KEY;
name = Globals.ERROR_KEY;
property = null;
header = null;
footer = null;
message = null;
}
}

Run again the project

How to consume a Web Service in a Portlet Project with Eclipse

2011-06-16T21:26:00.000-07:00

For this example I'm using Eclipse Helios and Ubuntu 10.04
First of all, download CXF2 from http://www.apache.org/dyn/closer.cgi?path=/cxf/2.4.1/apache-cxf-2.4.1.zip and extract it in any place of your computer.

Next,I suggest that you install the WTP plugins for Eclipse to continue

After that, we have to configure CXF2 enviroment. We have to open preferences from Window menu.
In CXF2.x Preferences we have to set the CXF2 runtime environment. This target is the place where we extracted CXF2

After that, we have to create a Portlet Project.

Next, click on Advanced project configuration...

Check CXF 2.x Web Services, click ok

Click Next

Select Liferay MVC and check Create custom portlet class.

Set the name for the portlet class, package and superclass(javax.portlet.GenericPortlet)
Click Next

Click Next

Click Next

Next, click on Finish.

After that, create a Web Service Client into the project

Set the Service Definition as: http://www.webservicex.net/globalweather.asmx?WSDL .In addition, set the Web service runtime as Apache CXF 2.x And set the service scale to Start Client. After that, click on Next

set the Package name to net.webservicex.example. Click on Next

Click next

Click on Start Server

Wait until the Server starts. Next, click on Finish

Open com.example.Weather.java and change doView function to:
public void doView(RenderRequest renderRequest,
RenderResponse renderResponse) throws IOException, PortletException {
try {
GlobalWeather service = new GlobalWeather();
GlobalWeatherSoap port = service.getGlobalWeatherSoap();
// TODO initialize WS operation arguments here
String cityName = "Quito";
String countryName = "Ecuador";
// TODO process result here
String result = port.getWeather(cityName, countryName);
renderRequest.setAttribute("info", result);
System.out.println("Result = " + result);
} catch (Exception ex) {
// TODO handle custom exceptions here
}
include(viewJSP, renderRequest, renderResponse);
}

Also, change view.jsp to print the result of the WS invocation.
<%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet" %>

${info}

Finally, Run the project on Liferay Server and add the portlet.

How to set up Eclipse environment to develop a Portlet Project

2011-06-16T15:30:00.000-07:00

This example uses Eclipse Helios, Ubuntu 10.04 and Liferay V6.0(Tomcat)
First of all, download liferay-portal-tomcat-6.0.6-20110225.zip and liferay-plugins-sdk-6.0.6-20110225.zip from http://sourceforge.net/projects/lportal/files/Liferay%20Portal/6.0.6/

Next, open Eclipse and go to Help/Install New Software. After that, click Add to add a new repository. Set the name as Liferay and the location as http://releases.liferay.com/tools/ide/eclipse/helios/stable

Then, you have to select Liferay repository and check Liferay Tools and click Next to download Liferay plugins for Eclipse. Also, you have to accept the license.

When the process installation finishes, you must restart Eclipse IDE.

Next, extract the contents of liferay-portal-tomcat-6.0.6-20110225.zip and liferay-plugins-sdk-6.0.6-20110225.zip in any directory of your computer.

After that, configure a New Server in Eclipse. You must lookup for Liferay V6.0

Set the Liferay Tomcat Directory(this target must be the Tomcat server which is into Liferay server).

Set the Tomcat bundle zip(this target must be the ext.zip into the ext directory of the liferay-plugins-sdk)

Finally, click Finish.

Now, we have to configure the Eclipse preferences for Liferay.

Lookup for Liferay Installed Plugin. Click add.

Set the location where you extracted liferay-plugins-sdk and set a name. Finally, click OK

click ok again.

Then we are going to create our first project.
click on File/new/Liferay Project

Set the name for the project

Click Next.

Select Liferay MVC and check Create Custom portlet class

Click Next.

Set name for the portlet class, set a java package and select javax.portlet.GenericPortlet as superclass then Click Next.

You may change the name of the portlet for Liferay, click Next

Also, you may change the css styles also set the category where the portlet will be set. Click Next

In this screen you should check the option processAction to process information which will be sent from a form.

Next, change view.jsp to:
<%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet" %>
<portlet:defineObjects />
${message}
<form id="formData" action="<portlet:actionURL/>" method="POST">
<table>
<tr><td>Phone:</td><td><input type="text" name="phone"></td></tr>
<tr><td>Email:</td><td><input type="text" name="email"></td></tr>
<tr><td><input type="submit" value="Send Info"></td>
<td><input type="reset" value="Clean"></td></tr>
</table>
</form>

Next, create a new JSP page. Right Click over the project new/other/Web/JSP

set the name result.jsp

Change result.jsp to:
<%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet" %>
<portlet:defineObjects />
${info}

After that, open the file PorletTest.java.

Change processAction to:
public void processAction(
ActionRequest actionRequest, ActionResponse actionResponse)
throws IOException, PortletException {
String phone = (String) actionRequest.getParameter("phone");
String email = (String) actionRequest.getParameter("email");
String info="You entered the following information:"+phone+","+email;
actionResponse.setRenderParameter("info", info);
}

Also, Change doView method to:
public void doView(
RenderRequest renderRequest, RenderResponse renderResponse)
throws IOException, PortletException {
if(renderRequest.getParameter("info")==null){
renderRequest.setAttribute("message", "Please, enter your phone number and email");
include(viewJSP, renderRequest, renderResponse);
}else{
renderRequest.setAttribute("info",renderRequest.getParameter("info"));
PortletRequestDispatcher prd = getPortletContext().getRequestDispatcher("/html/portlettest/result.jsp");
prd.include(renderRequest, renderResponse);
}
}

Next, right click over the project. Select Run on Server and choose Liferay V.6 and click Finish.

The liferay server home page will be opened.

Sign in as user test@liferay.com with password test

Click on Add/more and lookup for PortletTest. Next click add.

The form will appear. Enter the data

Click Send Info

Usando Clases Embebidas

2011-06-16T11:56:00.000-07:00

Para este ejemplo estoy utilizando Netbeans 6.9, Ubuntu 10.04, Glassfish V3 y DerbyDB

Primeramente creamos un Enterprise Project al que llamaremos ClasesEmbebidas.

Luego vamos a crear un Session Bean del tipo Stateless, con interface remota llamado Utilitario en el paquete com.ejemplo.session.

Despues vamos a crear una unidad de persistencia, llamada puClasesEmbebidas, con Toplink, datasource jdbc/sample y con la estrategia de generacion de tablas Drop and Create.

Después de esto creamos el paquete com.ejemplo.entity

Dentro de este paquete, creamos una clase llamada Direccion, con el siguiente código:

package com.ejemplo.entity;

import java.io.Serializable;
import javax.persistence.Embeddable;

@Embeddable
public class Direccion implements Serializable{
private String ciudad;
private String calle;
private String numero;

public Direccion(){

}

public Direccion(String ciudad, String calle, String numero) {
this.ciudad = ciudad;
this.calle = calle;
this.numero = numero;
}

public String getCalle() {
return calle;
}

public void setCalle(String calle) {
this.calle = calle;
}

public String getCiudad() {
return ciudad;
}

public void setCiudad(String ciudad) {
this.ciudad = ciudad;
}

public String getNumero() {
return numero;
}

public void setNumero(String numero) {
this.numero = numero;
}
}

También dentro de este paquete, creamos una clase llamada Persona, con el siguiente código:
package com.ejemplo.entity;

import java.io.Serializable;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Persona implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String nombre;
private String telefono;
@Embedded
private Direccion direccion;

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public Direccion getDireccion() {
return direccion;
}

public void setDireccion(Direccion direccion) {
this.direccion = direccion;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getTelefono() {
return telefono;
}

public void setTelefono(String telefono) {
this.telefono = telefono;
}
}

Luego cambiamos Utilitario.java al siguiente código:
package com.ejemplo.session;

import com.ejemplo.entity.Direccion;
import com.ejemplo.entity.Persona;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class Utilitario implements UtilitarioRemote {

@PersistenceContext
EntityManager em;

public void crearPersona() {
Persona persona=new Persona();
persona.setId(1L);
persona.setNombre("Santiago");
persona.setDireccion(new Direccion("Quito","Amazonas y NNUU","1023"));
persona.setTelefono("593212345678");
em.persist(persona);
}
}

Cambiamos Main.java y colocamos el siguiente código:
package clasesembebidas;

import com.ejemplo.session.UtilitarioRemote;
import javax.ejb.EJB;

public class Main {

@EJB private static UtilitarioRemote utilitario;

public static void main(String[] args) {
utilitario.crearPersona();
}

}

y al ver los servicios, veremos que se creó una tabla llamada direccion, con los atributos de la clase Direccion.

Heredando de una clase no Entity

2011-06-16T11:21:00.000-07:00

Para este ejemplo estoy utilizando Netbeans 6.9, Ubuntu 10.04, Glassfish V3 y DerbyDB

Primeramente creamos un Enterprise Project al que llamaremos Generico.

Luego vamos a crear un Session Bean del tipo Stateless, con interface remota llamado Utilitario en el paquete com.ejemplo.session.

Despues vamos a crear una unidad de persistencia, llamada puGenerico, con Toplink, datasource jdbc/sample y con la estrategia de generacion de tablas Drop and Create.

Después de esto creamos el paquete com.ejemplo.entity y tambien el paquete com.ejemplo.util

Dentro de com.ejemplo.util, creamos la clase llamada CuentaUsuarios
cuyo código es el siguiente.
package com.ejemplo.util;

public class CuentaUsuarios {

private Integer numeroUsuarios;

public CuentaUsuarios() {
numeroUsuarios = 0;
}

public Integer getNumeroUsuarios() {
return numeroUsuarios;
}

public void setNumeroUsuarios(Integer numeroUsuarios) {
this.numeroUsuarios = numeroUsuarios;
}

public void incrementarUsuariosConectados() {
numeroUsuarios++;
}
}
Luego dentro de com.ejemplo.entity creamos dos clases:
Usuario cuyo código es:
package com.ejemplo.entity;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Usuario implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Column(name = "login", nullable = false)
private String login;
@Column(name = "clave", nullable = false)
private String clave;
@ManyToOne
private Ciudad ciudad;

public Usuario() {
}

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public Ciudad getCiudad() {
return ciudad;
}

public void setCiudad(Ciudad ciudad) {
this.ciudad = ciudad;
}

public String getClave() {
return clave;
}

public void setClave(String clave) {
this.clave = clave;
}

public String getLogin() {
return login;
}

public void setLogin(String login) {
this.login = login;
}

}

y tambien Ciudad cuyo código es:
package com.ejemplo.entity;
import com.ejemplo.util.CuentaUsuarios;
import java.io.Serializable;
import java.util.Collection;
import java.util.Vector;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;

@Entity
public class Ciudad extends CuentaUsuarios implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Column(name = "nombre", nullable = false)
private String nombre;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "ciudad")
private Collection usuarioCollection = new Vector();

public Ciudad() {
}

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public Collection getUsuarioCollection() {
return usuarioCollection;
}

public void setUsuarioCollection(Collection usuarioCollection) {
this.usuarioCollection = usuarioCollection;
}

public void agregarUsuarios(Usuario User){
usuarioCollection.add(User);
incrementarUsuariosConectados();
System.out.println("El numero de usuarios conectados es:"+getNumeroUsuarios());
}
}
Esta clase extiende funcionalidad de Cuenta Usuarios. Esta clase tiene una función local llamada agregarUsuarios que usa otra funcion de la clase(incrementarUsuariosConectados) para llevar un control del número de usuarios.

Como siguiente paso hacemos el siguiente cambio en el código de Utilitario:

package com.ejemplo.session;

import com.ejemplo.entity.Ciudad;
import com.ejemplo.entity.Usuario;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class Utilitario implements UtilitarioRemote {

@PersistenceContext EntityManager em;

public void crearUsuarioCuidad() {
Ciudad ciudad=new Ciudad();
ciudad.setId(12L);
ciudad.setNombre("Quito");
Usuario usuario1=new Usuario();
usuario1.setId(1L);
usuario1.setLogin("username1");
usuario1.setClave("abc123");
usuario1.setCiudad(ciudad);
Usuario usuario2=new Usuario();
usuario2.setId(2L);
usuario2.setLogin("username2");
usuario2.setClave("xyz123");
usuario2.setCiudad(ciudad);
ciudad.agregarUsuarios(usuario1);
ciudad.agregarUsuarios(usuario2);
em.persist(ciudad);
}

}

Cuya interface es:

package com.ejemplo.session;

import javax.ejb.Remote;
@Remote
public interface UtilitarioRemote {
public void crearUsuarioCuidad();
}

Finalmente cambiamos Main.java

package generico;

import com.ejemplo.session.UtilitarioRemote;
import javax.ejb.EJB;
public class Main {
@EJB private static UtilitarioRemote utilitario;
public static void main(String[] args) {
utilitario.crearUsuarioCuidad();
}
}

y ejecutamos el proyecto empresarial.

Uso de Mapeo de Superclases

2011-06-16T10:04:00.001-07:00

Para este ejemplo estoy usando Netbeans 6.9, Ubuntu 10.04, Glassfish V3 y Derby DB

Imaginemos que tenemos un diagrama de objetos que deberán persistir en la base de datos, por ejemplo:

En esta guía vamos a explicar como persistir esta información en la base de datos.

Primeramente creamos un nuevo enterprise project al cual llamaremos SuperclaseDB.

Luego de esto vamos a crear Session Bean, del tipo Stateless, con interface remota, en el paquete com.ejemplo.session y llamado Utilitario

Ahora vamos a crear una unidad de persistencia en el proyecto EJB llamada puSuperclase, con proveedor de persistencia TopLink.
Creamos un nuevo Datasource, al cual llamaremos jdbc/sample y como estrategia de generación de tablas seleccionamos Drop and Create y damos click en Finish.

Una vez hecho esto, vamos a crear el paquete com.ejemplo.entity.persona

Ahi, vamos a crear la clase Direccion, que tendrá la siguiente forma:
package com.ejemplo.entity.persona;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Version;

@Entity
public class Direccion implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Version
protected Long version;
private String ciudad;
private String calle;

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public String getCalle() {
return calle;
}

public void setCalle(String calle) {
this.calle = calle;
}

public String getCiudad() {
return ciudad;
}

public void setCiudad(String ciudad) {
this.ciudad = ciudad;
}
}

Luego creamos la clase Abstracta Persona, con la siguiente notación:
package com.ejemplo.entity.persona;

import java.io.Serializable;
import javax.persistence.CascadeType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.MappedSuperclass;
import javax.persistence.OneToOne;
import javax.persistence.Version;

@MappedSuperclass
public abstract class Persona implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@OneToOne(cascade = {CascadeType.ALL})
@JoinColumn(name = "DIRECCION_CASA", referencedColumnName = "ID")
private Direccion direccion;
@Version
private Long version;

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public Persona() {
}

public Direccion getDireccion() {
return direccion;
}

public void setDireccion(Direccion direccion) {
this.direccion = direccion;
}
}

Voy a explicar brevemente las anotaciones de esta clase:
@MappedSuperclass: Para indicar que es una super clase mapeada
@Id: Para indicar un PK
@GeneratedValue: Usado para indicar que usaremos una tabla de secuencia
@OneToOne:Tendra una relación de uno-uno con Direccion
@JoinColumn la columna de la tabla local será "DIRECCION_CASA y se relacionará a ID en la tabla direccion
@Version: para llever la versión del registro

Luego creamos una clase llamada Gerente, con el siguiente código:
package com.ejemplo.entity.persona;

import java.io.Serializable;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
@DiscriminatorColumn(name = "TYPE")
public class Gerente extends Persona implements Serializable {

private String email;
private String departamento;

public Gerente() {
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public String getDepartamento() {
return departamento;
}

public void setDepartamento(String departamento) {
this.departamento = departamento;
}
}

Finalmente creamos una clase socio, con la siguiente notación:
package com.ejemplo.entity.persona;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Socio extends Persona implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String celular;
private String codigoSocio;

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public String getCelular() {
return celular;
}

public void setCelular(String celular) {
this.celular = celular;
}

public String getCodigoSocio() {
return codigoSocio;
}

public void setCodigoSocio(String codigoSocio) {
this.codigoSocio = codigoSocio;
}
}

Nota: En esta clase puse nuevamente un id, debido a que con el ejemplo quiero mostrar que el pk, puede ser sobreescrito por una de las clases hijas

Luego modificamos Utilitario, agregando el siguiente código:
package com.ejemplo.session;

import com.ejemplo.entity.persona.Direccion;
import com.ejemplo.entity.persona.Gerente;
import com.ejemplo.entity.persona.Socio;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class Utilitario implements UtilitarioRemote {
@PersistenceContext EntityManager em;

public void crearPersona() {
Gerente ger=new Gerente();
ger.setEmail("gerente@hotmail.com");
ger.setDepartamento("RRHH");
Direccion direccion=new Direccion();
direccion.setCalle("Amazonas");
direccion.setCiudad("Quito");
direccion.setId(1L);
ger.setDireccion(direccion);
Socio socio=new Socio();
socio.setId(123L);
socio.setDireccion(direccion);
socio.setCelular("098767899");
socio.setCodigoSocio("ASA56FF");
em.persist(ger);
em.persist(socio);
}
}

Su interface tendrá el siguiente código:
package com.ejemplo.session;

import javax.ejb.Remote;

@Remote
public interface UtilitarioRemote {
public void crearPersona();
}

Finalmente modificamos Main.java, al siguiente código:
package superclasedb;

import com.ejemplo.session.UtilitarioRemote;
import javax.ejb.EJB;

public class Main {
@EJB private static UtilitarioRemote utilitario;
public static void main(String[] args) {
utilitario.crearPersona();
}
}

y ejecutamos el ejemplo, teniendo la siguiente información en la base de datos:

Estrategias en modelado de herencia

2011-06-16T07:31:00.001-07:00

Para este ejemplo estoy usando Netbeans 6.9, Ubuntu 10.04, Glassfish V3 y Derby DB

Tenemos tres tipos de estrategias para utilizar herencia en nuestro modelado de objetos:
Modelo de una sola tabla
Modelo de tabla por clase
Modelo de subclase con Join.

Primeramente creamos un nuevo enterprise project al cual llamaremos HerenciaDB.

Luego de esto vamos a crear Session Bean, del tipo Stateless, con interface remota, en el paquete com.ejemplo.session y llamado Utilitario

Ahora vamos a crear una unidad de persistencia en el proyecto EJB llamada puHerencia, con proveedor de persistencia EclipseLink 2.0.
Usaremos el DataSource jdbc/sample y como estrategia de generación de tablas seleccionamos Drop and Create y damos click en Finish.

Una vez hecho esto, vamos a crear el paquete com.ejemplo.entity.empleado.

Dentro de ese paquete, vamos a crear tres clases:
La primera es Empleado(que debe implementar Serializable), que tendra como variables miembro: id y version. Creamos el getter y setter para id y agregamos las respectivas anotaciones, con lo cual el código nos queda como:

package com.ejemplo.entity.empleado;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;
import javax.persistence.Version;

@Entity
@Table(name = "EMP")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Empleado implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Integer id;
@Version
protected Integer version;

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}
}

Aquí podemos hacer una breve explicación de las anotaciones:
@Entity: Para indicar que es un EJB de Entidad
@Table(name="EMP"): Para indicar con que tabla se relacionará
@Inheritance(strategy=InheritanceType.XXX):Para indicar el tipo de estrategia de herencia que usaremos.
@Id: Indicar que la variable que se escribe a continuación es PK en la DB.
@GeneratedValue(strategy = GenerationType.AUTO): Para indicar que se usará una tabla de secuencia para la generación del PK.
@Version: Para indicar que es un campo que se encargará de llevar la versión del registro.

Una vez creada esta clase, vamos a crear otra llamada EmpleadoTiempoCompleto que extenderá de Empleado y tendra variables miembro y funciones propias, además de implementar Serializable, es decir:

package com.ejemplo.entity.empleado;

import java.io.Serializable;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;

@Entity
@Table(name="FT_EMP")
@DiscriminatorValue("FT")
public class EmpleadoTiempoCompleto extends Empleado implements Serializable {
private static final long serialVersionUID = 1L;
protected Integer salario;

public Integer getSalario() {
return salario;
}

public void setSalario(Integer salario) {
this.salario = salario;
}
}

Luego creamos una clase que se llame EmpleadoTiempoParcial que extenderá de Empleado y tendra variables miembro y funciones propias, además de implementar Serializable, es decir:

package com.ejemplo.entity.empleado;

import java.io.Serializable;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Table;

@Entity
@Table(name="PT_EMP")
@DiscriminatorValue("PT")
public class EmpleadoTiempoParcial extends Empleado implements Serializable {
protected Float horasTrabajo;

public Float getHorasTrabajo() {
return horasTrabajo;
}

public void setHorasTrabajo(Float horasTrabajo) {
this.horasTrabajo = horasTrabajo;
}
}

Luego de esto, vamos a modificar Utilitario, agregando funcionalidad que nos permita utilizar el Entity Beans creados.
package com.ejemplo.session;

import com.ejemplo.entity.empleado.EmpleadoTiempoCompleto;
import com.ejemplo.entity.empleado.EmpleadoTiempoParcial;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class Utilitario implements UtilitarioRemote {

@PersistenceContext EntityManager em;

public void crearEmpleadoTiempoCompleto() {
EmpleadoTiempoCompleto empleadoTC=new EmpleadoTiempoCompleto();
empleadoTC.setId(1);
empleadoTC.setSalario(1000);
em.persist(empleadoTC);
}

public void crearEmpleadoTiempoParcial() {
EmpleadoTiempoParcial empleadoTP=new EmpleadoTiempoParcial();
empleadoTP.setHorasTrabajo(3.5F);
empleadoTP.setId(2);

em.persist(empleadoTP);
}

}

La interface remota de Utilitario tendrá:
package com.ejemplo.session;

import javax.ejb.Remote;

@Remote
public interface UtilitarioRemote {

public void crearEmpleadoTiempoCompleto();

public void crearEmpleadoTiempoParcial();
}

Finalmente modificamos la clase Main de la siguiente manera:

package herenciadb;

import com.ejemplo.session.UtilitarioRemote;
import javax.ejb.EJB;

public class Main {

@EJB private static UtilitarioRemote utilitario;

public static void main(String[] args) {
utilitario.crearEmpleadoTiempoCompleto();
utilitario.crearEmpleadoTiempoParcial();
}

}

y ejecutamos el proyecto:
Si hacemos una consulta a la base de datos, tenemos:

Donde debemos notar una columna discriminante llamada FT para Empleados Tiempo Completo y PT para empleados tiempo parcial.

Ahora vamos a cambiar la estrategia de generacion. En la clase Empleado cambiamos @Inheritance(strategy=InheritanceType.SINGLE_TABLE) por @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) y ejecutamos nuevamente el proyecto.

Si vemos el schema de la base de datos, veremos dos nuevas tablas: FT_EMP y PT_EMP

Ahora vamos a cambiar la estrategia de generacion. En la clase Empleado cambiamos @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) por @Inheritance(strategy=InheritanceType.JOINED). y en la clase EmpleadoTiempoCompleto luego de @Table(name="FT_EMP") agregamos:@PrimaryKeyJoinColumn(name="FT_EMPID") Esto para colocar un nombre a la columna encargada de manetener la relación. Es por eso que PT_EMPID seguirá conservando el label de ID como PK.

Ejecutamos nuevamente el proyecto.

Java Persistence Query Language

2011-06-14T19:26:00.001-07:00

Para este ejemplo estoy utilizando Netbeans 6.9, Ubuntu 10.04, Glassfish 3.0 y Derby DB.
En este ejemplo voy a ejemplificar el funcionamiento de EJB en un Enterprise Project. Para esto vamos a crear un Enterprise Project llamado ConsultasEJBQL.

Luego de eso en el proyecto EJB vamos a crear una unidad de persistencia. La llamaremos puEJBQL, EclipseLink será el proveedor de persistencia y apuntará al datasource jdbc/sample de Derby y como estrategia de generación de las tablas, seleccionamos None.

Hecho esto, vamos a crear beans de entidad por medio de la opción: "Entity Classes from Database"
Seleccionamos todas las tablas, damos click sobre Next.

Luego colocamos un paquete, en este caso es: com.ejemplo.ejb.entity y damos click sobre Next.

En la caja de selección de Collection Type, seleccionamos java.util.List y damos click en Finish.

Una vez creados los Entity Beans vamos a crear un Session Bean del tipo Stateless, con interface remoto, llamado Utilitario en el paquete com.ejemplo.ejb.session

A continuación muesto ciertas consultas EJBQL, definidas en Utilitario.

package com.ejemplo.ejb.session;

import com.ejemplo.ejb.entity.Customer;
import com.ejemplo.ejb.entity.Manufacturer;
import com.ejemplo.ejb.entity.Product;
import com.ejemplo.ejb.entity.ProductCode;
import java.util.List;
import java.util.Vector;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

@Stateless
public class Utilitario implements UtilitarioRemote {

@PersistenceContext
EntityManager em;

@Override
public void getAllCustomers() {
String consulta1 = "select obj from Customer obj";
System.err.println("____CONSULTA CUSTOMER____");
Query query = em.createQuery(consulta1);
for (Customer customer : (List) query.getResultList()) {
System.out.println(customer.getName());
}
}

@Override
public void getCustomerByName(String parametro) {
String consulta2 = "select obj from Customer obj where obj.city=:ciudad";
System.err.println("____CONSULTA CUSTOMER PARAMETRIZADA____");
Query query = em.createQuery(consulta2);
query.setParameter("ciudad", parametro);
for (Customer customer : (List) query.getResultList()) {
System.out.println(customer.getName());
}
}

@Override
public void consultaMaximoResultados() {
String consulta1 = "select obj from Customer obj";
System.err.println("____CONSULTA MAXIMA RESULTADOS____");
Query query = em.createQuery(consulta1);
query.setMaxResults(5);
for (Customer customer : (List) query.getResultList()) {
System.out.println(customer.getName());
}
}

@Override
public void consultaUnica() {
String resultadoUnico = "select obj from Customer obj where obj.customerId=:id";
System.err.println("____CONSULTA UNICA____");
Integer parametro = 1;
Query query = em.createQuery(resultadoUnico);
query.setParameter("id", parametro);
Customer customer = (Customer) query.getSingleResult();
System.out.println(customer.getName());
}

@Override
public void consultarNamedQuery() {
String consultaNamedQuery = "Product.findAll";
System.err.println("____CONSULTA NAMED QUERY____");
Query query = em.createNamedQuery(consultaNamedQuery);
for (Product product : (List) query.getResultList()) {
System.out.println(product.getDescription());
}
}

@Override
public void consultarNamedQueryAddress() {
String consultaNamedQueryDireccion = "Customer.findByAddressline1";
System.err.println("____CONSULTA NAMED QUERY DIRECCION____");
Query query = em.createNamedQuery(consultaNamedQueryDireccion);
query.setParameter("addressline1", "9754 Main Street");
for (Customer customer : (List) query.getResultList()) {
System.out.println(customer.getName());
}
}

@Override
public void consultarNativeQuery() {
String consultaNativeQuery = "Select * from Manufacturer";
System.err.println("____CONSULTA NAMED QUERY____");
Query query = em.createNativeQuery(consultaNativeQuery, Manufacturer.class);
for (Manufacturer fabricante : (List) query.getResultList()) {
System.out.println(fabricante.getName());
}
}

@Override
public void consultarNativeQueryLista() {
String consultaNativeQueryList = "Select name,state,city from Manufacturer";
System.err.println("____CONSULTA NATIVE QUERY____");
Query query = em.createNativeQuery(consultaNativeQueryList);
List resultados = (List) query.getResultList();
for (int i = 0; i < resultados.size(); i++) {
//System.out.println((Vector) resultados.get(i));//Usado para TopLink
System.out.println(java.util.Arrays.toString((Object[]) resultados.get(i)));//Usado para EclipseLink
}
}

@Override
public void consultarPosicional() {
String consultaPosicional = "select obj from Manufacturer obj where obj.city=?1";
System.err.println("____CONSULTAR POSICIONAL____");
String parametro1 = "San Jose";
Query query = em.createQuery(consultaPosicional);
query.setParameter(1, parametro1);
for (Manufacturer manufacturer : (List) query.getResultList()) {
System.out.println(manufacturer.getName());
}
}

@Override
public void consultaGrupo() {
String consultaGrupo = "select pc.prodCode from ProductCode pc GROUP BY pc.prodCode";
System.err.println("____CONSULTA GRUPO____");
Query query = em.createQuery(consultaGrupo);
List resultados = (List) query.getResultList();
for (int i = 0; i < resultados.size(); i++) {
System.out.println((String) resultados.get(i));
}
}

@Override
public void actualizar() {
String update = "UPDATE MicroMarket mm SET mm.areaLength=mm.areaWidth";
Query query = em.createQuery(update);
query.executeUpdate();
}

@Override
public void eliminar() {
Manufacturer m = new Manufacturer();
m.setManufacturerId(777);
m.setName("ejemplo");
m.setAddressline1("Amazonas");
m.setAddressline2("NNUU");
m.setCity("Quito");
m.setState("Pi");
m.setZip("123");
m.setPhone("123456789");
m.setFax("987654321");
m.setEmail("ejemplo@gmail.com");
m.setRep("cualquiera");
em.persist(m);
String delete = "DELETE FROM Manufacturer c WHERE c.name ='ejemplo'";
Query query = em.createQuery(delete);
query.executeUpdate();
}

@Override
public void consultaGroupBy() {
String consultaGroupBy = "SELECT p.productCode.prodCode,AVG(p.purchaseCost) FROM Product p GROUP BY p.productCode.prodCode ORDER BY p.productCode.prodCode ASC";
System.err.println("____CONSULTA GROUP BY____");
Query query = em.createQuery(consultaGroupBy);
List resultados = (List) query.getResultList();
for (int i = 0; i < resultados.size(); i++) {
System.out.println(((Object[]) resultados.get(i))[0] + "," + ((Object[]) resultados.get(i))[1]);
}
}

@Override
public void consultaPrecios() {
String consultarValoresEntre = "SELECT p FROM Product p WHERE p.purchaseCost<:maximo AND p.purchaseCost>:minimo";
System.err.println("____CONSULTA VALOR ENTRE____");
Query query = em.createQuery(consultarValoresEntre);
query.setParameter("maximo", new Double(40));
query.setParameter("minimo", new Double(10));
for (Product p : (List) query.getResultList()) {
System.out.println(p.getDescription());
}
}

@Override
public void consultaPrecios2() {
String consultarValoresEntre2 = "SELECT p FROM Product p WHERE p.purchaseCost BETWEEN :minimo AND :maximo";
System.err.println("____CONSULTA VALOR ENTRE 2____");
Query query = em.createQuery(consultarValoresEntre2);
query.setParameter("maximo", new Double(40));
query.setParameter("minimo", new Double(10));
for (Product p : (List) query.getResultList()) {
System.out.println(p.getDescription());
}
}

@Override
public void consultaLike() {
String consultarLike = "SELECT p FROM Product p WHERE p.description LIKE 'Lea%'";
System.err.println("____CONSULTA LIKE____");
Query query = em.createQuery(consultarLike);
for (Product p : (List) query.getResultList()) {
System.out.println(p.getDescription());
}
}

@Override
public void consultaJoin() {
String consultaJoin1 = "select pc FROM ProductCode pc join pc.productList p WHERE p.purchaseCost>10000";
System.err.println("____CONSULTA JOIN____");
Query query = em.createQuery(consultaJoin1);
for (ProductCode pc : (List) query.getResultList()) {
System.out.println(pc.getDescription());
}
}

@Override
public void consultarJoin2() {
String consultarJoin2 = "select p from Product p LEFT join p.productCode HW";
System.err.println("____CONSULTA JOIN____");
Query query = em.createQuery(consultarJoin2);
for (Product p : (List) query.getResultList()) {
System.out.println(p.getDescription());
}
}

@Override
public void consultarJoin3() {
String consultarJoin3 = "SELECT Object(pc) FROM ProductCode pc, IN (pc.productList) pl where pc.prodCode='SW'";
System.err.println("____CONSULTA JOIN____");
Query query = em.createQuery(consultarJoin3);
for (ProductCode pc : (List) query.getResultList()) {
System.out.println(pc.getDescription());
}
}

@Override
public void consultarJoin4() {
String consultarJoin4 = "select pc FROM ProductCode pc join pc.productList p WHERE p.quantityOnHand>50";
System.err.println("____CONSULTA JOIN____");
Query query = em.createQuery(consultarJoin4);
for (ProductCode pc : (List) query.getResultList()) {
System.out.println(pc.getDescription());
}
}

@Override
public void consultarJoin5() {
String consultarJoin5 = "SELECT DISTINCT pc FROM ProductCode pc, IN(pc.productList) l WHERE l.manufacturer.name = 'Acer'";
System.err.println("____CONSULTA JOIN____");
Query query = em.createQuery(consultarJoin5);
for (ProductCode pc : (List) query.getResultList()) {
System.out.println(pc.getDescription());
}
}

@Override
public void consultarJoin6() {
String consultarJoin6 = "SELECT pc from ProductCode pc LEFT JOIN pc.productList o WHERE pc.prodCode='SW'";
System.err.println("____CONSULTA JOIN____");
Query query = em.createQuery(consultarJoin6);
for (ProductCode pc : (List) query.getResultList()) {
System.out.println(pc.getDescription());
}
}

@Override
public void consultaFuncion() {
String consultaFuncionRaiz = "select SQRT(p.purchaseCost) from Product p";
System.err.println("____CONSULTA FUNCION SQRT____");
Query query = em.createQuery(consultaFuncionRaiz);
List resultados = (List) query.getResultList();
for (int i = 0; i < resultados.size(); i++) {
System.out.println((Double) resultados.get(i));
}
}
}

Esta es la interface remota de Utilitario:

package com.ejemplo.ejb.session;

import javax.ejb.Remote;

@Remote
public interface UtilitarioRemote {
public void getAllCustomers();

public void getCustomerByName(String ciudad);

public void consultaMaximoResultados();

public void consultaUnica();

public void consultarNamedQuery();

public void consultarNamedQueryAddress();

public void consultarNativeQuery();

public void consultarNativeQueryLista();

public void consultarPosicional();

public void consultaJoin();

public void consultaGrupo();

public void consultaFuncion();

public void actualizar();

public void eliminar();

public void consultarJoin2();

public void consultarJoin3();

public void consultaGroupBy();

public void consultaPrecios();

public void consultaPrecios2();

public void consultaLike();

public void consultarJoin4();

public void consultarJoin5();

public void consultarJoin6();

}

y este es el código de la clase Main:

package consultaejbql;

import com.ejemplo.ejb.session.UtilitarioRemote;
import javax.ejb.EJB;

public class Main {

@EJB private static UtilitarioRemote utilitario;
public static void main(String[] args) {
utilitario.getAllCustomers();
utilitario.getCustomerByName("New York");
utilitario.consultaMaximoResultados();
utilitario.consultaUnica();
utilitario.consultarNamedQuery();
utilitario.consultarNamedQueryAddress();
utilitario.consultarNativeQuery();
utilitario.consultarNativeQueryLista();
utilitario.consultarPosicional();
utilitario.consultaJoin();
utilitario.consultaFuncion();
utilitario.consultaGrupo();
utilitario.actualizar();
utilitario.eliminar();
utilitario.consultarJoin3();
utilitario.consultaPrecios();
utilitario.consultaPrecios2();
utilitario.consultaLike();
utilitario.consultaGroupBy();
}
}

y la salida es:
SEVERE: ____CONSULTA CUSTOMER____
INFO: Instantiated an instance of org.hibernate.validator.engine.resolver.JPATraversableResolver.
INFO: EclipseLink, version: Eclipse Persistence Services - 2.0.1.v20100213-r6600
INFO: file:/home/santiago/NetBeansProjects/ConsultaEJBQL/dist/gfdeploy/ConsultaEJBQL/ConsultaEJBQL-ejb_jar/_puEJBQL login successful
INFO: JumboCom
INFO: Livermore Enterprises
INFO: Oak Computers
INFO: Nano Apple
INFO: HostProCom
INFO: CentralComp
INFO: Golden Valley Computers
INFO: ejemplo
INFO: West Valley Inc.
INFO: Ford Motor Co
INFO: Big Car Parts
INFO: New Media Productions
INFO: Yankee Computer Repair
SEVERE: ____CONSULTA CUSTOMER PARAMETRIZADA____
INFO: New Media Productions
INFO: Yankee Computer Repair
SEVERE: ____CONSULTA MAXIMA RESULTADOS____
INFO: JumboCom
INFO: Livermore Enterprises
INFO: Oak Computers
INFO: Nano Apple
INFO: HostProCom
SEVERE: ____CONSULTA UNICA____
INFO: JumboCom
SEVERE: ____CONSULTA NAMED QUERY____
INFO: Identity Server
INFO: Accounting Application
INFO: 1Ghz Sun Blade Computer
INFO: 10Gb Ram
INFO: Sound Card
INFO: Printer Cable
INFO: 24 inch Digital Monitor
INFO: 104-Key Keyboard
INFO: Directory Server
INFO: 512X IDE DVD-ROM
INFO: Learn Solaris 10
INFO: Network Cable
INFO: 300Mhz Pentium Computer
INFO: Learn NetBeans
INFO: Corporate Expense Survey
INFO: Sun Studio C++
INFO: Client Server Testing
INFO: Learn Java in 1/2 hour
INFO: Writing Web Service Applications
INFO: Jax WS Application Development Environment
INFO: Java EE 6 Application Development Environment
INFO: Java Application Development Environment
INFO: NetBeans Development Environment
INFO: Solaris x86 Computer
INFO: Ultra Spacr 999Mhz Computer
INFO: 686 7Ghz Computer
INFO: A1 900 watts Speakers
INFO: Mini Computer Speakers
INFO: Computer Tool Kit
INFO: Flat screen Monitor
SEVERE: ____CONSULTA NAMED QUERY DIRECCION____
INFO: Livermore Enterprises
SEVERE: ____CONSULTA NAMED QUERY____
INFO: Google
INFO: Sun MicroSystems
INFO: Acer
INFO: Matrox
INFO: 3Com
INFO: CBX Cables
INFO: Sony
INFO: Getaway
INFO: SoftClip
INFO: Toshiba
INFO: Sams Publishing
INFO: Computer Cables & More
INFO: BMC
INFO: Rico Enterprises
INFO: Dobs Computer Products
INFO: Zetsoft
INFO: Hitachi
INFO: World Savings
INFO: Wells Fargo
INFO: Bank Of America
INFO: Google
INFO: Google
INFO: Google
INFO: Sun MicroSystems
INFO: Sun MicroSystems
INFO: Sun MicroSystems
INFO: Sun MicroSystems
INFO: Sun MicroSystems
INFO: Sun MicroSystems
INFO: Sun MicroSystems
INFO: fabricante1
INFO: fabricante1
INFO: fabricante1
INFO: fabricante1
INFO: Ejemplo Clase
INFO: fabricante1
SEVERE: ____CONSULTA NATIVE QUERY____
INFO: [Google, CA, Mountain View]
INFO: [Sun MicroSystems, CA, Santa Clara]
INFO: [Acer, CA, San Jose]
INFO: [Matrox, CA, Novato]
INFO: [3Com, CA, El Cerrito]
INFO: [CBX Cables, IN, Indianapolis]
INFO: [Sony, CA, San Francisco]
INFO: [Getaway, CA, Santa Clara]
INFO: [SoftClip, MA, Boston]
INFO: [Toshiba, CA, Van Nuys]
INFO: [Sams Publishing, MA, Reading]
INFO: [Computer Cables & More, MI, Dearborn]
INFO: [BMC, CA, Pleasanton]
INFO: [Rico Enterprises, NY, New York]
INFO: [Dobs Computer Products, NM, Albuqerque]
INFO: [Zetsoft, AZ, Tombstone]
INFO: [Hitachi, CA, San Mateo]
INFO: [World Savings, CA, Oakland]
INFO: [Wells Fargo, CA, San Francisco]
INFO: [Bank Of America, CA, San Francisco]
INFO: [Google, CA, Mountain View]
INFO: [Google, CA, Mountain View]
INFO: [Google, CA, Mountain View]
INFO: [Sun MicroSystems, CA, Santa Clara]
INFO: [Sun MicroSystems, CA, Santa Clara]
INFO: [Sun MicroSystems, CA, Santa Clara]
INFO: [Sun MicroSystems, CA, Santa Clara]
INFO: [Sun MicroSystems, CA, Santa Clara]
INFO: [Sun MicroSystems, CA, Santa Clara]
INFO: [Sun MicroSystems, CA, Santa Clara]
INFO: [fabricante1, null, null]
INFO: [fabricante1, null, null]
INFO: [fabricante1, null, null]
INFO: [fabricante1, null, null]
INFO: [Ejemplo Clase, null, null]
INFO: [fabricante1, null, null]
SEVERE: ____CONSULTAR POSICIONAL____
INFO: Acer
SEVERE: ____CONSULTA JOIN____
INFO: Software
SEVERE: ____CONSULTA FUNCION SQRT____
INFO: 33.090784215548595
INFO: 107.24266874709897
INFO: 45.78198335590104
INFO: 7.742738533619742
INFO: 6.320601237224193
INFO: 3.997499218261337
INFO: 24.392621835300936
INFO: 3.3090784215548594
INFO: 7.067531393633848
INFO: 8.363611660042569
INFO: 5.475399528801528
INFO: 5.094114250780011
INFO: 44.73197961190629
INFO: 5.472659317004851
INFO: 8.660254037844387
INFO: 24.412087170088512
INFO: 4.466542286825459
INFO: 4.3531597719357835
INFO: 4.998999899979995
INFO: 14.489651479590528
INFO: 16.122964987867462
INFO: 16.430155203162265
INFO: 14.830711378757258
INFO: 37.429266623859995
INFO: 28.284094470214175
INFO: 24.412087170088512
INFO: 8.36540495134575
INFO: 7.067531393633848
INFO: 6.078651166171653
INFO: 14.140367746278736
SEVERE: ____CONSULTA GRUPO____
INFO: BK
INFO: CB
INFO: FW
INFO: HW
INFO: MS
INFO: SW
SEVERE: ____CONSULTA JOIN____
INFO: Software
INFO: Software
INFO: Software
INFO: Software
INFO: Software
INFO: Software
INFO: Software
INFO: Software
SEVERE: ____CONSULTA VALOR ENTRE____
INFO: Sound Card
INFO: Printer Cable
INFO: 104-Key Keyboard
INFO: Learn Solaris 10
INFO: Network Cable
INFO: Learn NetBeans
INFO: Client Server Testing
INFO: Learn Java in 1/2 hour
INFO: Writing Web Service Applications
INFO: Computer Tool Kit
SEVERE: ____CONSULTA VALOR ENTRE 2____
INFO: Sound Card
INFO: Printer Cable
INFO: 104-Key Keyboard
INFO: Learn Solaris 10
INFO: Network Cable
INFO: Learn NetBeans
INFO: Client Server Testing
INFO: Learn Java in 1/2 hour
INFO: Writing Web Service Applications
INFO: Computer Tool Kit
SEVERE: ____CONSULTA LIKE____
INFO: Learn Solaris 10
INFO: Learn NetBeans
INFO: Learn Java in 1/2 hour
SEVERE: ____CONSULTA GROUP BY____
INFO: BK,24.764
INFO: CB,20.965
INFO: FW,49.95
INFO: HW,717.2372
INFO: MS,55.975
INFO: SW,1775.2112

Métodos Callback para EJBs de Entidad

2011-06-13T23:21:00.001-07:00

Para este ejemplo estoy usando Netbeans 6.9, Ubuntu 10.04, Glassfish V3 y Derby

Primeramente vamos a crear un Enterprise Project llamado CallBackEntity.

Creamos una unidad de persistencia que la llamaremos como:pucb. Seleccionamos TopLink como la libreria de persistencia. Como Conexión a la Base de Datos seleccionamos la conexión a la base de datos de sample de Derby y como la estrategia de generación de las tablas seleccionamos None.

Luego de esto, tenemos que crear un Entity Bean en base a las tablas del schema de la base de datos.Para lograr esto creamos un EntityBean usando "Entity Classes from DataBase". Al abrirse la ventana seleccionamos y pasamos al lado derecho la tabla Manufacturer.

Luego damos click en Next y colocamos el paquete com.ejemplo.entity.

Damos click en Next y la siguiente ventana en la opción collection list, seleccionamos java.util.List y damos click en Finish.

Hecho esto se nos genera el Entity Bean llamado Manufacturer.

En esta clase vamos a agregar las anotaciones relacionadas a las operaciones con la base de datos.

Tambien cambiamos el método toString(), para poder imprimir las variable miembro.

Con lo que el código nos queda como:

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.entity;

import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.PostLoad;
import javax.persistence.PostPersist;
import javax.persistence.PostRemove;
import javax.persistence.PostUpdate;
import javax.persistence.PrePersist;
import javax.persistence.PreRemove;
import javax.persistence.PreUpdate;
import javax.persistence.Table;

/**
*
* @author santiago
*/
@Entity
@Table(name = "MANUFACTURER")
@NamedQueries({
@NamedQuery(name = "Manufacturer.findAll", query = "SELECT m FROM Manufacturer m"),
@NamedQuery(name = "Manufacturer.findByManufacturerId", query = "SELECT m FROM Manufacturer m WHERE m.manufacturerId = :manufacturerId"),
@NamedQuery(name = "Manufacturer.findByName", query = "SELECT m FROM Manufacturer m WHERE m.name = :name"),
@NamedQuery(name = "Manufacturer.findByAddressline1", query = "SELECT m FROM Manufacturer m WHERE m.addressline1 = :addressline1"),
@NamedQuery(name = "Manufacturer.findByAddressline2", query = "SELECT m FROM Manufacturer m WHERE m.addressline2 = :addressline2"),
@NamedQuery(name = "Manufacturer.findByCity", query = "SELECT m FROM Manufacturer m WHERE m.city = :city"),
@NamedQuery(name = "Manufacturer.findByState", query = "SELECT m FROM Manufacturer m WHERE m.state = :state"),
@NamedQuery(name = "Manufacturer.findByZip", query = "SELECT m FROM Manufacturer m WHERE m.zip = :zip"),
@NamedQuery(name = "Manufacturer.findByPhone", query = "SELECT m FROM Manufacturer m WHERE m.phone = :phone"),
@NamedQuery(name = "Manufacturer.findByFax", query = "SELECT m FROM Manufacturer m WHERE m.fax = :fax"),
@NamedQuery(name = "Manufacturer.findByEmail", query = "SELECT m FROM Manufacturer m WHERE m.email = :email"),
@NamedQuery(name = "Manufacturer.findByRep", query = "SELECT m FROM Manufacturer m WHERE m.rep = :rep")})
public class Manufacturer implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@Basic(optional = false)
@Column(name = "MANUFACTURER_ID")
private Integer manufacturerId;
@Column(name = "NAME")
private String name;
@Column(name = "ADDRESSLINE1")
private String addressline1;
@Column(name = "ADDRESSLINE2")
private String addressline2;
@Column(name = "CITY")
private String city;
@Column(name = "STATE")
private String state;
@Column(name = "ZIP")
private String zip;
@Column(name = "PHONE")
private String phone;
@Column(name = "FAX")
private String fax;
@Column(name = "EMAIL")
private String email;
@Column(name = "REP")
private String rep;

public Manufacturer() {
}

public Manufacturer(Integer manufacturerId) {
this.manufacturerId = manufacturerId;
}

public Integer getManufacturerId() {
return manufacturerId;
}

public void setManufacturerId(Integer manufacturerId) {
this.manufacturerId = manufacturerId;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getAddressline1() {
return addressline1;
}

public void setAddressline1(String addressline1) {
this.addressline1 = addressline1;
}

public String getAddressline2() {
return addressline2;
}

public void setAddressline2(String addressline2) {
this.addressline2 = addressline2;
}

public String getCity() {
return city;
}

public void setCity(String city) {
this.city = city;
}

public String getState() {
return state;
}

public void setState(String state) {
this.state = state;
}

public String getZip() {
return zip;
}

public void setZip(String zip) {
this.zip = zip;
}

public String getPhone() {
return phone;
}

public void setPhone(String phone) {
this.phone = phone;
}

public String getFax() {
return fax;
}

public void setFax(String fax) {
this.fax = fax;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public String getRep() {
return rep;
}

public void setRep(String rep) {
this.rep = rep;
}

@Override
public int hashCode() {
int hash = 0;
hash += (manufacturerId != null ? manufacturerId.hashCode() : 0);
return hash;
}

@Override
public boolean equals(Object object) {
// TODO: Warning - this method won't work in the case the id fields are not set
if (!(object instanceof Manufacturer)) {
return false;
}
Manufacturer other = (Manufacturer) object;
if ((this.manufacturerId == null && other.manufacturerId != null) || (this.manufacturerId != null && !this.manufacturerId.equals(other.manufacturerId))) {
return false;
}
return true;
}

@Override
public String toString() {
return " Manufacturer id:" + this.manufacturerId
+ " Name :" + this.name
+ " Address Line 1:" + this.addressline1
+ " Address Line 2:" + this.addressline2
+ " City:" + this.city
+ " State:" + this.state
+ " Zip:" + this.zip
+ " Phone:" + this.phone
+ " Fax:" + this.fax
+ " Email:" + this.email
+ " Rep:" + this.rep;
}

@PrePersist
public void antesGuardar() {
System.out.println("Antes de Guardar");
}

@PostPersist
public void luegoGuardar() {
System.out.println("Luego de Guardar");
}

@PreRemove
public void antesEliminar() {
System.out.println("Antes de Eliminar");
}

@PostRemove
public void luegoEliminar() {
System.out.println("Luego de Eliminar");
}

@PreUpdate
public void antesActualizar() {
System.out.println("Antes de Actualizar");
}

@PostUpdate
public void luegoActualizar() {
System.out.println("Luego de Actualizar");
}

@PostLoad
public void alCargar() {
System.out.println("Cargando el objeto en el contexto");
}
}

Después de esto creamos un EJB de Session Stateless con interface remota, llamado Utilitario, dentro de com.ejemplo.session. Que tenga funciones que se encarguen de llamar a rutinas para guardar, eliminar y actualizar la tabla Manufacturer en la base de datos.
Es decir:
package com.ejemplo.session;

import com.ejemplo.entity.Manufacturer;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class Utilitario implements UtilitarioRemote {

@PersistenceContext EntityManager em;

public void guardar(Manufacturer m) {
em.persist(m);
}

public void eliminar(Manufacturer m) {
em.remove(em.find(com.ejemplo.entity.Manufacturer.class, m.getManufacturerId()));
}

public void actualizar(Manufacturer m) {
em.merge(m);
}
}

Luego, hacemos clean and build sobre el Enterprise Project

Finalmente hacemos una inyección de EJB en la clase Main donde crearemos,actualizaremos y eliminaremos objetos del tipo Manufacturer. De esta manera:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package callbackentity;

import com.ejemplo.entity.Manufacturer;
import com.ejemplo.session.UtilitarioRemote;
import javax.ejb.EJB;

public class Main {
@EJB private static UtilitarioRemote util;
public static void main(String[] args) {
//Creando uno nuevo
Manufacturer m = new Manufacturer();
m.setManufacturerId(987);
m.setName("Santiago");
m.setAddressline1("Amazonas");
m.setAddressline2("NNUU");
m.setCity("Quito");
m.setState("Pi");
m.setZip("123");
m.setPhone("123456789");
m.setFax("987654321");
m.setEmail("ejemplo@gmail.com");
m.setRep("cualquiera");
util.guardar(m);
System.out.println(m.toString());
//Actualizando
m.setRep("cualquier12345");
util.actualizar(m);
System.out.println(m.toString());
//Eliminando
util.eliminar(m);
}
}

En el log de la aplicación tenemos:

y en el log de Glassfish tenemos:

Métodos CallBack para Session Beans

2011-06-13T20:17:00.000-07:00

Para este ejemplo estoy usando Netbeans 6.9, Ubuntu 10.04 y Glassfish V3

Los métodos callback son similares a usar triggers de una base de datos, es decir son ejecutados cuando se ejecuta alguna acción sobre el objeto, estas acciones pueden ser instanciación(constructor), eliminación(destructor), desactivar(stateful beans) o activar(stateful beans)

Para ejemplificar lo que hacen estos métodos, vamos a crear un Enterprise Project llamado CallbackSesion.

Luego de esto, vamos a crear un EJB de session del tipo stateless con interface remota llamado EJBStateless en el paquete com.ejemplo.stateless.

Tambien vamos a crear un session bean del tipo Stateful con interface remota llamado EJBStateful en el paquete com.ejemplo.stateful.

Para EJBStateless agregamos las funciones creacionObjeto y eliminarObjeto, con el siguiente código:

package com.ejemplo.stateless;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.ejb.Remove;
import javax.ejb.Stateless;

@Stateless
public class EJBStateless implements EJBStatelessRemote {

@PostConstruct
public void creacionObjeto() {
System.err.println("Se esta creando el objeto Stateless");
}

public void mostrarMensaje() {
System.out.println("Este es un EJB de session de tipo Stateless");
}

@Remove
public void eliminarObjeto() {
System.out.println("..........Se esta ejecutando funcion para eliminar el objeto Stateless");
}

@PreDestroy
public void mensajePreDestroy() {
System.err.println(".......Etapa de Pre Destroy Stateless");
}
}

Para EJBStateful agregamos las funciones creacionObjeto y eliminarObjeto, con el siguiente código:
package com.ejemplo.stateful;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.ejb.Remove;
import javax.ejb.Stateful;

@Stateful
public class EJBStateful implements EJBStatefulRemote {

@PostConstruct
public void creacionObjeto() {
System.err.println("Se esta creando el objeto Stateful");
}

public void mostrarMensaje() {
System.out.println("Este es un EJB de session de tipo Stateful");
}

@Remove
public void eliminarObjeto() {
System.out.println("Se esta ejecutando funcion para eliminar el objeto Stateful");
}

@PreDestroy
public void mensajePreDestroy() {
System.err.println("Etapa de Pre Destroy Stateful");
}

}
Tenemos que destacar que en el código antes escrito se usan las anotaciones @PostConstruct y @PreDestroy, estas sirven para señalar que funciones se ejecutarán. También la anotación @Remove, que es la que nos permitirá indicar la función que será la encargada de eliminar el objeto.

Hecho esto, vamos a realizar una inyección de EJB en la clase Main, de nuestro cliente.
Es decir:

package callbacksesion;

import com.ejemplo.stateful.EJBStatefulRemote;
import com.ejemplo.stateless.EJBStatelessRemote;
import javax.ejb.EJB;

public class Main {
@EJB private static EJBStatefulRemote stateful;
@EJB private static EJBStatelessRemote stateless;

public static void main(String[] args) {
stateless.mostrarMensaje();
stateful.mostrarMensaje();
stateful.eliminarObjeto();
stateless.eliminarObjeto();
}

}
Con lo que tenemos la siguiente salida:

y al detener el servidor:

Timer Services

2011-06-13T17:17:00.001-07:00

Para este ejemplo estoy usando Netbeans 6.9, Ubuntu 10.04 y Glassfish V3.
Un timer es una rutina que llamada cada cierto tiempo por el servidor de aplicaciones, es similar a un cron job.
Para probar como funcionan los timers vamos a crear un Enterprise Applicaction llamado TimerProject.
Luego creamos un EJB de Session, Stateles y con interface remota, en el paquete com.ejemplo Llamaremos a la clase Timer1

Después de esto agregamos una función llamada invocacion1(). Programaremos esta función para que se ejecute cada minuto.
Es decir:

package com.ejemplo;

import javax.ejb.Schedule;
import javax.ejb.Stateless;

@Stateless
public class Timer1 implements Timer1Remote {
@Schedule(minute="*",hour="*")
public void invocacion1() {
System.out.println("Esta es una invocación que se realiza cada minuto");
}
}

Luego hacemos click con el boton derecho sobre el EnterpriseProject y seleccionamos deploy.

Finalmente desde la pestaña de services levantamos el servidor

y esperamos un minuto para revisar el log del servidor:

Tenemos otra manera de ejecutar un timer y es por medio de la inyección de recursos.
Para este ejemplo voy a ejecutar un timer a los 1000 ms de iniciado el servidor y se ejecutará la función tarea() cada 20000 ms. Para eso debo crear la función llamada tarea():

Para eso voy a modificar la clase Timer1, de la siguiente manera:

package com.ejemplo;

import javax.annotation.Resource;
import javax.ejb.Schedule;
import javax.ejb.Stateless;
import javax.ejb.Timeout;
import javax.ejb.Timer;
import javax.ejb.TimerService;

@Stateless
public class Timer1 implements Timer1Remote {

int tiempoInicio=1000;
int tiempoRepeticion=20000;
String mensaje="Llamada a la rutina";
@Resource TimerService timerService;

@Schedule(minute="*",hour="*")
public void invocacion1() {
System.out.println("Esta es una invocación que se realiza cada x segundos");
}

public void crearTimer() {
System.out.println("Dentro del metodo crear Timer");
System.out.println("Cada "+tiempoRepeticion+" se ejecutará la función tarea");
Timer timer = timerService.createTimer(tiempoInicio,tiempoRepeticion,
mensaje);
}
@Timeout
public void tarea(Timer timer) {
System.out.println("Aqui se hará la respectiva codificación");
}

}

Al ejecutar tenemos la siguiente salida:

Métodos Callback de Interceptores

2011-06-13T15:02:00.001-07:00

Para este ejemplo estoy usando Ubuntu 10.04, Netbeans 6.9 y Glassfish V3.
En un post anterior usamos Interceptores con métodos de negocio. Para este post vamos a usar metodos callback en interceptores.
Tenemos cuatro tipos de anotaciones callback:
- PostConstruct(Stateless, Stateful y MDB)
- PreDestroy(Stateless, Stateful y MDB)
- PostActivate(Stateful)
- PrePassivate(Stateful)

Primeramente creamos un Enterprise Project llamado CallbackInterceptors.

Luego creamos un EJB del tipo Stateless con interface remota llamado Utilitario, dentro del paquete com.ejemplo.

Ahi creamos una función llamada mostrarMensaje que imprima en pantalla un saludo:

package com.ejemplo;

import javax.ejb.Stateless;

@Stateless
public class Utilitario implements UtilitarioRemote {

public void mostrarMensaje() {
System.out.println("Saludos desde el EJB");
}
}

Luego de eso creamos una clase interceptora llamada: ClaseInterceptoraLifeCycle en el paquete: com.ejemplo.interceptores. La cual va a tener las funciones:
mensajePostConstruct(InvocationContext inv) con la anotación: @PostConstructque será llamada luego de ejecutarse la inyección de EJB y la función mensajePreDestroy(InvocationContext inv) con la anotación:@PreDestroy que será llamda luego de ser eleiminado el objeto.
Es decir:

package com.ejemplo.interceptores;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.interceptor.InvocationContext;

public class ClaseInterceptoraLifeCycle {

@PostConstruct
public void mensajePostConstruct(InvocationContext inv){
System.out.println("Test PostConstruct");
}

@PreDestroy
public void mensajePreDestroy(InvocationContext inv){
System.out.println("Test PreDestroy");
}
}

Hecho esto, tenemos que modificar la clase Stateless EJB, para que soporte el Interceptor creado, para eso agregamos la anotación:@Interceptors({
com.ejemplo.interceptores.ClaseInterceptoraLifeCycle.class
})
Con lo que el código nos queda como:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package com.ejemplo;

import javax.ejb.Stateless;
import javax.interceptor.Interceptors;

/**
*
* @author santiago
*/
@Stateless
@Interceptors({
com.ejemplo.interceptores.ClaseInterceptoraLifeCycle.class
})
public class Utilitario implements UtilitarioRemote {

public void mostrarMensaje() {
System.out.println("Saludos desde el EJB");
}
}

Finalmente en la clase Main, hacemos la inyección de EJB a Utilitario

y obtenemos el siguiente resultado:

y si detenemos el servidor:

Usando Interceptores de Negocio(Business Interceptors)

2011-06-13T14:13:00.000-07:00

Para este ejemplo estoy usando Ubuntu 10.04, Netbeans 6.9 y Glassfish V3

La idea de usar interceptores en una aplicación EJB es la misma que usar Filtros en un aplicación Web.
Para ilustrar el uso de interceptores vamos a crear un Projecto Empresarial en Netbeans.
Ahora creamos un Stateless Session Bean con una interface remota, en el paquete com.ejemplo.ejb. Llamaremos al EJB como Utilitario

Hecho esto vamos a crear un metodo llamado mostrarMensaje(), que tiene un parámetro del tipo String.

La clase EJB nos quedará de la siguiente manera:

package com.ejemplo;

import javax.ejb.Stateless;

@Stateless
public class Utilitario implements UtilitarioRemote {
public void mostrarMensaje(String cadena) {
System.out.println("El parametro ingresado es:"+cadena);
}
}

Luego de esto desde el cliente EJB hacemos una Inyección EJB y llamamos al EJB Utilitario
Con lo cual el código nos queda como:

package interceptoresnegocio;

import com.ejemplo.UtilitarioRemote;
import javax.ejb.EJB;

public class Main {

@EJB private static UtilitarioRemote bean;
public static void main(String[] args) {
bean.mostrarMensaje("Esta es una prueba");
}

}

Luego ejecutamos el ejemplo y tenemos la siguiente salida:
INFO: El parametro ingresado es:Esta es una prueba

Hasta ahora nada de ciencia, pero en este momento vamos a cambiar el mensaje que se imprime

Primeramente, tenemos que crear un clase. Para esto damos boton derecho sobre el proyecto EJB y seleccionamos New Java Class.
Le damos el nombre de Interceptor1 y le creamos dentro del paquete:com.ejemplo.interceptores

La clase interceptora usa la anotación:@AroundInvoke y la clase InvocationContext, para obtener información de environment, por ejemplo: los métodos y los parámetros. Además siempre siempre debe devolver la función proceed de InvocationContext.
La clase interceptora, tendrá el siguiente código:

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package com.ejemplo.interceptores;

import javax.interceptor.AroundInvoke;
import javax.interceptor.InvocationContext;

/**
*
* @author santiago
*/
public class Interceptor1 {
@AroundInvoke
public Object interceptorClase(InvocationContext inv) throws Exception {
long tiempoInicio = System.currentTimeMillis();
String nombreFuncion = "";
Object[] parametros = null;
try {
nombreFuncion = inv.getMethod().getName();
parametros = inv.getParameters();
return inv.proceed();
} finally {
long tiempo = tiempoInicio - System.currentTimeMillis();
System.out.println(inv.getMethod() + " La ejecución en la clase Interceptora1 de la función "
+ nombreFuncion + " tomó:" + tiempo + "milliseconds.");
System.out.println("Con los parametros:"
+ java.util.Arrays.toString(parametros));
}
}
}

Hecho esto vamos a usar la anotación @Interceptors en la clase EJB que implementa la interface remota.Con lo que la clase nos queda como:

package com.ejemplo;

import javax.ejb.Stateless;
import javax.interceptor.Interceptors;

@Stateless
@Interceptors({
com.ejemplo.interceptores.Interceptor1.class
})
public class Utilitario implements UtilitarioRemote {

public void mostrarMensaje(String cadena) {
System.out.println("El parametro ingresado es:"+cadena);
}
}

Si ejecutamos la clase Main, veremos que en la consola nos sale la información del tiempo de ejecución de la clase

Ahora vamos a cambiar el valor del parámetro de la función mostrarMensaje por medio de un nuevo Interceptor.
Para esto creamos una clase que se llame InterceptorParametro de la misma manera que creamos la clase Interceptor1. Es decir:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.interceptores;

import javax.interceptor.AroundInvoke;
import javax.interceptor.InvocationContext;

/**
*
* @author santiago
*/
public class InterceptorParametro {

@AroundInvoke
public Object interceptorClase(InvocationContext inv) throws Exception {
try {
Object[] parametros = inv.getParameters();
parametros[0] = "Valor cambiado por el Interceptor";
inv.setParameters(parametros);
} finally {
return inv.proceed();
}
}
}

y agregamos el nuevo interceptor en la clase Utilitario, es decir:

package com.ejemplo;

import javax.ejb.Stateless;
import javax.interceptor.Interceptors;

@Stateless
@Interceptors({
com.ejemplo.interceptores.Interceptor1.class,
com.ejemplo.interceptores.InterceptorParametro.class
})
public class Utilitario implements UtilitarioRemote {

public void mostrarMensaje(String cadena) {
System.err.println("El parametro ingresado es:"+cadena);
}
}

y ejecutamos la Enterprise Application:
y obtenemos la siguiente salida:
SEVERE: El parametro ingresado es:Valor cambiado por el Interceptor