just my notes...

¿Un huevo de gallina es una célula?

2010-08-19T23:49:00.003+02:00

¿Un huevo de gallina es una célula?

Primero habría que aclararte que todas las células sin excpeción poseen tamaños microscópicos del orden de micras debido a factores físicos que impiden un crecimiento unitario celular mayor; y segundo creo que tienes algo de problema con el desarrollo embrionario, te aclaro que cuando vez al huevo como tal, este ya ha sufrido un proceso de predesarrollo al interior de la gallina mediante el cual el cigoto inicial sufre una serie (millones) de divisiones mitoticas que producen un tejido embrionario bastante considerable que es el que finalmente ocupa la yema del huevo mientras la clara es tejido nutricio (nutrición), de modo que en general el huevo como tal podría decirse es un agregado celular embrionario en un estadío post-inicial medio sin producción de tejidos especializados.

Creo que has sido víctima de uno de los grandes errores de la lingüística en la Biología:

El huevo no es una célula, antiguamente maestros confundían a sus estudiantes haciendo esta analogía entre huevo y célula pretendiendo solamente hacer una comparación debido a la forma y composición de este yema = núcleo; clara=citoplasma; cascara = membrana celular) y este error se multiplico en el tiempo.

Actualmente hay quienes aun piensan que el huevo es una célula, pero en realidad no lo es, esta conformado por millones de ellas.

fuente: http://es.answers.yahoo.com/question/index?qid=20080501201533AA46Shr

----

Es una mancha blanca pequeña, redonda, opaca, situada en la superficie de la yema del huevo.

Está formado por la unión de una sola célula producida en el ovario de la hembra y otra célula de esperma producida por el macho.

La célula hembra contiene la mitad del número total de cromosomas (información genética) y la célula masculina la otra mitad.

Después de la fusión o fertilización de las dos mitades la célula resultante se divide en dos, estas dos células crecen y se dividen una y otra vez hasta que el huevo sale al exterior. La masa de células es visible como el disco germinal. Durante la incubación esta masa de células crecerá, se dividirá y especializará para formar el polluelo, y usará el resto de los volúmenes del huevo como comida.

fuente: http://muticus-pina.com/huevo/huevo.htm

beped: @create

2010-05-29T22:53:00.000+02:00

probar @Create en el componente propertyConfigurator

hermes: Character encoding

2010-05-29T22:51:00.000+02:00

30.1.4.5. Character encoding

Sets the character encoding of submitted form data.
This filter is not installed by default and requires an entry in components.xml to enable it:

<web:character-encoding-filter encoding="UTF-16"
override-client="true"
url-pattern="*.seam"/>

• encoding — The encoding to use.
• override-client — If this is set to true, the request encoding will be set to whatever is
specified by encoding no matter whether the request already specifies an encoding or not. If
set to false, the request encoding will only be set if the request doesn't already specify an
encoding. The default setting is false.

Configuring a Seam EJB project for development with Maven and JBoss Tools

2010-05-08T15:51:00.001+02:00

Configuring a Seam EJB project for development with Maven and JBoss Tools

java parse fixed-length files (2)

2010-05-07T21:50:00.000+02:00

http://jsapar.tigris.org/

Mission

The goal of this project is to create a java library that contains a parser of flat files and csv files. The library should be simple to use and possible to extend.

Existing features

Support for flat files with fixed positions.
Support for CSV files.
The schema can be expressed with xml notation or created directly within the java code.
The parser can either produce a Document class, representing the content of the file, or you can choose to receive events for each line that has been successfully parsed.
Can handle huge files without loading everything into memory.
The output Document class contains a list of lines which contains a list of cells.
The Document class can be transformed into a Java object (via reflection) if the schema is carefully written.
It is also possible to produce java objects directly from the parser.
It is possible convert a list of java objects into a file according to a schema if the schema is carefully written.
The Document class can be built from a xml file (according to an internal xml schema).
The input and outputs are given by java.io.Reader and java.io.Writer which means that it is not necessarily files that are parsed or generated.
The file parsing schema contains information about how to parse each cell regarding data type and syntax.
Parsing errors can either be handled by exceptions thrown at first error or the errors can be collected during parsing to be able to deal with them later.
JUnit tests for most classes within the library.
Support for localisation.

Java Schema Parser

The javadoc within the package contains more comprehensive documentation regarding the classes mentioned below.

The JSaPar package is a java library that provides a parser for flat and CSV (Comma Separated Values) files. The concept is that a schema class denotes the way a file should be parsed or written. The schema class can be built by specifying a xml-document or it can be constructed programmatically by using java code. The output of the parser is usually a org.jsapar.Document object that contains a list of org.jsapar.Line objects which contains a list of org.jsapar.Cell objects.

Supported file formats:

Fixed width - Also refered to as flat file. Each cell is described only by its positions within the line. The type of the line is denoted by its position within the file.
Fixed width contol value - The same as Fixed width above except that each line type is denoted by a control value in the leading characters of each line.
CSV - (Comma Separated Values) Each cell is limited by a separator character (or characters). The type of the line is denoted by its position within the file.
CSV contol value - The same as CSV above except that each line type is denoted by a control value in the leading cell of each line.

Events for each line

For very large files there can be a problem to build the complete org.jsapar.Document in the memory before further processing. It may simply take up to much memory. In that case you may choose to get an event for each line that is parsed instead. You do that by registering a sub-class of org.jsapar.ParsingEventListener to the org.jsapar.input.Parser. That way you can process one line at a time, thus freeing memory as you go along.

Converter

If you are only interesting in converting a file of one format into another, you can use the org.jsapar.io.Converter where you specify the input and the output schema for the conversion. The converter uses the event mechanism under the hood, thus it reads, converts and writes one line at a time. This means it is very lean regarding memory usage.

Building java objects

Use the method org.jsapar.Parser.buildJava() in order to build java objects for each line in a file (or input). Note that in order to be able to use this feature, the schema have to be carefully written. For instance, the line type (name) of the line within the schema have to contain the complete class name of the java class to build for each line.

Converting java objects into a file

Use the class org.jsapar.input.JavaBuilder in order to convert java objects into a org.jsapar.Document, which can be used to produce the output file according to a schema.

Using xml as input

It is possilbe to build a org.jsapar.Document by using a xml document according to the XMLDocumentFormat.xsl (http://jsapar.tigris.org/XMLDocumentFormat/1.0). Use the class org.jsapar.input.XmlDocumentParser in order to convert a xml document into a org.jsapar.Document.

java parse fixed-length files

2010-05-07T21:37:00.001+02:00

parsing a text file in java

import org.apache.commons.lang.RandomStringUtils;
import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.Random;

public class GenerateFile {

public static void main(String[] args) throws Exception {
File file = new File("hugefile.txt");
PrintStream ps = new PrintStream(new FileOutputStream(file));
Random random = new Random(10);

StringBuffer sb = new StringBuffer();
for(int i=0; i<700000; i++){
for(int j=0; j<10; j++){
sb.append(RandomStringUtils.random(3+random.nextInt(10)%10, true, true));
if(j<9){
sb.append("|");
}
}
ps.println(sb.toString());
sb = new StringBuffer();
}

ps.close();
}
}

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.StopWatch;
import java.io.File;
import java.io.FileReader;
import java.io.BufferedReader;

public class TokenizeFile {

public static void main(String[] args) throws Exception {
File file = new File("hugefile.txt");
BufferedReader br = new BufferedReader(new FileReader(file));

StopWatch stopWatch = new StopWatch();

stopWatch.start();

String line = null;
long totalLinesProcessed = 0l;

while((line=br.readLine())!=null){
totalLinesProcessed ++;
StringUtils.split(line, "|");
}

stopWatch.stop();

br.close();

System.out.println("Total lines processed = "+totalLinesProcessed+" Time taken = "+stopWatch.getTime() +" ms");
}
}

If you run the above two files; you would be processing a 55 MB file.

A sample run results:
Total lines processed = 700000 Time taken = 4457 ms (1.6 GHZ, 512 MB RAM)

VTD-XML: The Future of XML Processing

2010-05-05T23:53:00.001+02:00

VTD-XML: The Future of XML Processing

The world's most memory-efficient (1.3x~1.5x the size of an XML document) random-access XML parser.
The world's fastest XML parser: On a Core2 2.5Ghz Laptop, VTD-XML outperforms DOM parsers by 5x~12x, delivering 90~120 MB/sec per core sustained throughput.
The world's fastest XPath 1.0 implementation.
The world's most efficient XML indexer that seamlessly integrates with your XML applications.
The world's only incremental-update capable XML parser capable of cutting, pasting, splitting and assembling XML documents with max efficiency.
The world's only XML parser that allows you to use XPath to process 256 GB XML documents.
The XML technology that they don't want you to know about.

ver el ejemplo 17:

/**
* This is a demonstration of how to use the extended VTD parser
* to process large XML file. You need 64-bit JVM to take full
* advantage of extended VTD.
*/
import com.ximpleware.extended.*;
public class mem_mapped_read {
public static void main(String[] s) throws Exception{
VTDGenHuge vg = new VTDGenHuge();
if (vg.parseFile("test.xml",true,VTDGenHuge.MEM_MAPPED)){
VTDNavHuge vnh = vg.getNav();
AutoPilotHuge aph = new AutoPilotHuge(vnh);
aph.selectXPath("//*");
int i = 0;
while ((i=aph.evalXPath())!=-1){
System.out.println(" element name is "+vnh.toString(i));
}
}
}
}

XMLBeans Support for Built-In Schema Types

2010-05-05T22:25:00.000+02:00

XMLBeans Support for Built-In Schema Types

Built-In Schema Type	XMLBean Type	Natural Java Type
xs:anyType	XmlObject	org.apache.xmlbeans.XmlObject
xs:anySimpleType	XmlAnySimpleType	String
xs:anyURI	XmlAnyURI	String
xs:base64Binary	XmlBase64Binary	byte[]
xs:boolean	XmlBoolean	boolean
xs:byte	XmlByte	byte
xs:date	XmlDate	java.util.Calendar
xs:dateTime	XmlDateTime	java.util.Calendar
xs:decimal	XmlDecimal	java.math.BigDecimal
xs:double	XmlDouble	double
xs:duration	XmlDuration	org.apache.xmlbeans.GDuration
xs:ENTITIES	XmlENTITIES	String
xs:ENTITY	XmlENTITY	String
xs:float	XmlFloat	float
xs:gDay	XmlGDay	java.util.Calendar
xs:gMonth	XmlGMonth	java.util.Calendar
xs:gMonthDay	XmlGMonthDay	java.util.Calendar
xs:gYear	XmlGYear	java.util.Calendar
xs:gYearMonth	XmlGYearMonth	java.util.Calendar
xs:hexBinary	XmlHexBinary	byte[]
xs:ID	XmlID	String
xs:IDREF	XmlIDREF	String
xs:IDREFS	XmlIDREFS	String
xs:int	XmlInt	int
xs:integer	XmlInteger	java.math.BigInteger
xs:language	XmlLanguage	String
xs:long	XmlLong	long
xs:Name	XmlName	String
xs:NCName	XmlNCNAME	String
xs:negativeInteger	XmlNegativeInteger	java.math.BigInteger
xs:NMTOKEN	XmlNMTOKEN	String
xs:NMTOKENS	XmlNMTOKENS	String
xs:nonNegativeInteger	XmlNonNegativeInteger	java.math.BigInteger
xs:nonPositiveInteger	XmlNonPositiveInteger	java.math.BigInteger
xs:normalizedString	XmlNormalizedString	String
xs:NOTATION	XmlNOTATION	Not supported
xs:positiveInteger	XmlPositiveInteger	java.math.BigInteger
xs:QName	XmlQName	javax.xml.namespace.QName
xs:short	XmlShort	short
xs:string	XmlString	String
xs:time	XmlTime	java.util.Calendar
xs:token	XmlToken	String
xs:unsignedByte	XmlUnsignedByte	short
xs:unsignedInt	XmlUnsignedInt	long
xs:unsignedLong	XmlUnsignedLong	java.math.BigInteger
xs:unsignedShort	XmlUnsignedShort	int

XMLBeans Tools

2010-05-05T22:24:00.000+02:00

XMLBeans Tools

XMLBeans includes several command-line tools you might find handy as shortcuts for common tasks. You'll find these tools in the bin directory of the XMLBeans installation or source tree.

dumpxsb (XSB File Dumper): Prints the contents of an XSB file in human-readable form.

inst2xsd (Instance to Schema Tool): Generates XML schema from XML instance files.

scomp (Schema Compiler): Compiles a schema into XMLBeans classes and metadata.

scopy (Schema Copier): Copies the XML schema at the specified URL to the specified file.

sdownload (Schema Downloader): Maintains "xsdownload.xml," an index of locally downloaded XSD files. URLs that are specified are downloaded if they aren't already cached. If no files or URLs are specified, all indexed files are relevant.

sfactor (Schema Factoring Tool): Factors redundant definitions out of a set of schemas and uses imports instead.

svalidate (Streaming Instance Validator): Validates a schema definition and instances within the schema.

validate (Instance Validator): Validates an instance against a schema.

xpretty (XML Pretty Printer): Pretty prints the specified XML to the console.

xsd2inst (Schema to Instance Tool): Prints an XML instance from the specified global element using the specified schema.

xsdtree (Schema Type Hierarchy Printer): Prints an inheritance hierarchy of the types defined in a schema.

xmlbean Ant task: Compiles a set of XSD and/or WSDL files into XMLBeans types.

Open Source XML Parsers in Java

2010-05-05T20:26:00.003+02:00

Open Source XML Parsers in Java

Para la aplicación beped debemos encontrar el parser que mejor se adapte a nuestras necesidades.
Los que más parecen ajustarse son:

XMLBeans

At a high level XMLBeans is an XML-Java binding tool that uses XML Schema as a basis for generating Java classes that you can use to easily access XML instance data in a natural manner in your Java programs. It was designed to provide both easy access to XML information via convenient Java classes as well as complete access to the underlying XML, combining the best of low-level APIs like SAX and DOM that provide full access with the convenience of Java binding. There are several factors that set XMLBeans apart from any other XML-Java binding alternatives:

* XML Schema Compliance - XMLBeans has achieved extremely high schema compliance and is able to compile even the most complex schemas. This is critical when adopting an XML-Java binding framework since you may received schemas that are out of your control.
* Access to the full underlying XML Infoset - The XML Cursor API allows you to access a lower level DOM like access to the underying XML Infoset. You can get a "cursor" at any point while using the strongly typed generated XMLBeans and begin navigating the underlying XML instance.
* Access to the schema type system - The XMLBeans schema API allows you to walk through the schema type system giving you full access to a Java object representation of the XML Schema that was compiled to generate the XMLBeans classes.
* Speed - XMLBeans is optimized for performance at many levels. For example, XMLBeans lazily constructs objects from XML, so that you do not have the performance overhead of object creation when you only access portions of an XML document. Several Fortune 500 customers have adopted XMLBeans based on speed alone.

JAXB

The Java Architecture for XML Binding (JAXB) provides a fast and convenient way to bind between XML schemas and Java representations, making it easy for Java developers to incorporate XML data and processing functions in Java applications

JiBX: Binding XML to Java Code

JiBX is a framework for binding XML data to Java objects. It lets you work with data from XML documents using your own class structures. The JiBX framework handles all the details of converting your data to and from XML based on your instructions. JiBX is designed to perform the translation between internal data structures and XML with very high efficiency, but still allows you a high degree of control over the translation process.

VTD-XML 1.5 (xcuriosidad)

VTD-XML is the next generation XML parser that goes beyond DOM and SAX in terms of performance, memory and ease of use. To XML developers, VTD-XML is simple and just works! Other innovative features include XML indexing (due to inherent persistence of VTD) and incremental update. It is also the world's fastest XML processor: On an Athlon64 3400+ PC, VTD-XML significantly (1.5x~2x) outperforms SAX parsers with NULL content handler, delivering 50~60 MB/sec sustained throughput, without sacrificing random access. Its memory usage is typically between 1.3x~1.5x the size of the XML document, with 1 being the XML itself.

Zeus

Zeus is, in a nutshell, an open source Java-to-XML Data Binding tool. It provides a means of taking an arbitrary XML document and converting that document into a Java object representing the XML. That Java object can then be used and manipulated like any other Java object in the VM (virtual machine). Then, once the object has been modified and operated upon, Zeus can be used to convert the Java object back into an XML representation.

HERMES: Taylor identity para LDAP

2010-05-02T21:50:00.001+02:00

Ldap

Using a database identity store is great for development and small applications. However, for enterprise applications you will want to use Ldap.

The following shows how to configure the Taylor Identity Ldap implementation.

ant tasks in maven

2010-04-26T01:24:00.001+02:00

Para correr los test del build.xml desde maven:

TestNG & Maven: How to configure it correctly

<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<executions>
<execution>
<id>pre-test</id>
<phase>process-test-resources</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<move todir="${project.build.outputDirectory}">
<fileset dir="${project.build.outputDirectory}">

<include name="META-INF/persistence.xml"/>
</fileset>
<mapper type="glob" from="*" to="*~"/>
</move>
</tasks>
</configuration>
</execution>
<execution>
<id>post-test</id>
<phase>test</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<move todir="${project.build.outputDirectory}">
<fileset dir="${project.build.outputDirectory}" defaultexcludes="false">
<include name="**/*~"/>
</fileset>
<mapper type="glob" from="*~" to="*"/>
</move>
</tasks>
</configuration>
</execution>
</executions>
</plugin>

SeamTest and Maven

2010-04-26T01:05:00.001+02:00

SeamTest and Maven

Using SeamTest with Maven can be a challenge because the Embedded JBoss container on which SeamTest relies is not very classpath friendly. It brings its own solar system of JAR files with it and those can easily conflict with the classpath built by Maven. Please see the following thread on how best to integrate the two:

TestNG and Maven - How To Configure It Correctly

Play close attention to the responses Dan gives.

para probar Arquilian en hermes

2010-04-26T00:46:00.001+02:00

Getting started

3.1. Setting up Arquillian in a Maven project
3.2. Writing your first Arquillian test
3.3. Setting up and running the test in Maven
3.4. Setting up and running the test in Eclipse
3.5. Setting up and running the test in NetBeans

We've promised you that integration testing with Arquillian is no more complicated than writing a unit test. Now it's time to prove it to you. In this chapter, we'll look at what is required to setup Arquillian in your project, how to write an Arquillian test case, how to execute the test case and how the test results are displayed. That sounds like a lot, but you'll be writing your own Arquillian tests in no time. (You'll also learn about Chapter 7, Debugging remote tests in Chapter 7).

TestNG

2010-04-26T00:16:00.002+02:00

reference-guide

@BeforeSuite: The annotated method will be run before all tests in this suite have run.

@AfterSuite: The annotated method will be run after all tests in this suite have run.

@BeforeTest: The annotated method will be run before any test method belonging to the classes inside the tag is run.

@AfterTest: The annotated method will be run after all the test methods belonging to the classes inside the tag have run.

@BeforeGroups: The list of groups that this configuration method will run before. This method is guaranteed to run shortly before the first test method that belongs to any of these groups is invoked.

@AfterGroups: The list of groups that this configuration method will run after. This method is guaranteed to run shortly after the last test method that belongs to any of these groups is invoked.

@BeforeClass: The annotated method will be run before the first test method in the current class is invoked.

@AfterClass: The annotated method will be run after all the test methods in the current class have been run.

@BeforeMethod: The annotated method will be run before each test method.

@AfterMethod: The annotated method will be run after each test method.

@ParametersDescribes how to pass parameters to a @Test method.

@Test
dependsOnGroups
The list of groups this method depends on.
dependsOnMethods
The list of methods this method depends on.
expectedExceptionsThe list of exceptions that a test method is expected to throw. If no exception or a different than one on this list is thrown, this test will be marked a failure.
sequential
If set to true, all the methods on this test class are guaranteed to run sequentially, even if the tests are currently being run with parallel="methods". This attribute can only be used at the class level and it will be ignored if used at the method level.

5.13 - Running TestNG programmatically

You can invoke TestNG from your own programs very easily:

TestListenerAdapter tla = new TestListenerAdapter();
TestNG testng = new TestNG();
testng.setTestClasses(new Class[] { Run2.class });
testng.addListener(tla);
testng.run();

Arquilian

2010-04-25T23:52:00.001+02:00

Test-in container

Arquillian provides a easy mechanism to test your application code inside a remote or embedded container or by interacting as a client of the container.

To avoid introducing unnecessary complexity into the developer's build environment, Arquillian integrates transparently with familiar testing frameworks (e.g., JUnit 4, TestNG 5), allowing tests to be launched using existing IDE, Ant and Maven test plugins without any add-ons.

Para lo de unique numeroOrden-turno

2010-04-19T21:47:00.000+02:00

crear un Custom Assertion Validator

hermes: validating properties referencing another object

2010-04-01T00:28:00.001+02:00

2.1.5. Object graphs

The Bean Validation API does not only allow to validate single class instances but also complete object graphs. To do so, just annotate a field or property representing a reference to another object with @Valid. If the parent object is validated, all referenced objects annotated with @Valid will be validated as well (as will be their children etc.)

2.3. Validating groups

Groups allow you to restrict the set of constraints applied during validation. This makes for example wizard like validation possible where in each step only a specified subset of constraints get validated. The groups targeted are passed as var-args parameters to validate, validateProperty and validateValue. Let's have a look at an extended Car with Driver example. First we have the class Person (Example 2.12, “Person”) which has a @NotNull constraint on name. Since no group is specified for this annotation its default group is javax.validation.groups.Default.

hibernate: procesos batch

2010-03-31T23:55:00.000+02:00

Procesos batch

si por alguna razón queremos deshabilitar o evitar el uso del cache, podemos usar un tipo especial de session: StatelessSession, se obtiene de la sessionFactory con el método openStatelessSession(). Yo la uso en el caso de los procesos batch, por ejemplo cuando tengo que hacer inserts o updates masivos, así evito que cada vez que hago el save de un objeto, el mismo me quede en memoria y en el correr del proceso se produzca un error del tipo OutOfMemoryError. La StatelessSession no interactúa con el First Level Cache ni con el Second Level Cache, es casi como si utilizáramos JDBC directamente.

@PreUpdate @PrePersist

2010-03-29T23:20:00.002+02:00

prueba de @PreUpdate

no pasa por el preUpdate de booking ni con los Home ni con el entityManager

código de la prueba (action1.java)

package org.domain.test11.session;

import javax.persistence.EntityManager;

import org.domain.test11.entity.Booking;
import org.domain.test11.entity.Hotel;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Logger;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.international.StatusMessages;
import org.jboss.seam.log.Log;

@Name("action1")
public class Action1
{
@Logger private Log log;

@In StatusMessages statusMessages;

@In(create=true) BookingHome bookingHome;
@In(create=true) HotelHome hotelHome;
public void action1()
{
// implement your business logic here
log.info("action1.action1() action called");
statusMessages.add("action1");

update3();

}

@In EntityManager entityManager;
public void update2() {
Booking b = (Booking)entityManager.find(Booking.class, new Long(1));
b.getCustomer().setName("pepero");
entityManager.persist(b);
}

public void update3() {
Hotel hotel = hotelHome.getEntityManager().find(Hotel.class, new Long(1));
Booking booking = bookingHome.getEntityManager().find(Booking.class, new Long(1));
booking.getHotel().setCity("madrid3");
booking.getCustomer().setName("manolo6");
bookingHome.setInstance(booking);
bookingHome.update();
}

// add additional action methods

}

para los logs de los procesos

2010-03-24T23:12:00.003+01:00

en este código se puede ver cómo añadir un appender al logger de la clase. La clase llamará a un método en un servicio pasándole el logger, y este servicio añadirá al logger el appender.
También podemos pasar del log de seam y configurar el logger de la forma clásica en log4j (como en el ejemplo siguiente).

package es.imserso.sample.log;
import java.io.IOException;
import java.util.Enumeration;

import org.apache.log4j.Appender;
import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.SimpleLayout;

public class Inicio {

static Logger logger = Logger.getLogger(Inicio.class);

/**
* @param args
*/
public static void main(String[] args) {
PropertyConfigurator.configure("log4j.properties");

logger.info("comienzo de la aplicación");

Inicio i = new Inicio();
i.ejecuta();

logger.info("fin de la aplicación");

}

private void ejecuta() {

try {
Appender appender = null;
logger.addAppender(new FileAppender(new SimpleLayout(), "proceso2.log"));
logger.info("iniciando proceso...");
logger.info("este fichero tiene que ser proceso2.log");

Enumeration e = logger.getAllAppenders();

while (e.hasMoreElements()) {
appender = e.nextElement();
appender.setName("myappender");
}

logger.info("finalizando proceso...");
logger.removeAppender(appender);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
logger.error("mosramos un error");

}

}

New (3.2.3) Hibernate identifier generators

2010-03-17T01:56:00.002+01:00

Desde la url Hibernate Core 3.3.1 released, pinchamos en enhanced id generators y accedemos a una página donde se detallan exhaustivamente los drásticos cambios que se han hecho en esta versión.

Lo más importante es lo que pone en la conclusion:

Conclusion

I would expect that these two new generators actually replace currently existing ones in terms of short-hand names. Specifically, I would expect

the implementation behind sequence to change from org.hibernate.SequenceGenerator to the new org.hibernate.id.enhanced.SequenceStyleGenerator

the implementation behing table to change from org.hibernate.TableGenerator to the new org.hibernate.id.enhanced.TableGenerator

The second is the more risky replacement because of the big difference between the two. But we've all along discouraged direct use of the current table generator so I think we should be safe there. I am still uncertain when that replacement will happen (probably 4.0?), but in the meantime, the new generators are available and highly recommended for use.

Hay que pensarlo bien, parece que lo mejor es usar estos nuevos generadores

Unified error page and exception handling

2010-03-17T00:47:00.001+01:00

Unified error page and exception handling

A web application can run into a server-side error for many different reasons and at any point in time. Finding the right strategy for your application, how to deal with these error conditions and exceptional situations, can be difficult. This page provides some guidelines and a simple but effective solution.

When a client request is handled by a web application server, exceptions can be thrown by code at any time. Typically, you need to consider:

Exceptions thrown by the web application server, usually the servlet container. For example, exceptions you definitely have to expect and handle include session limit violations. If your servlet container reaches its configured maximum active session limit, your users should be presented with a nice error message that tells them to come back later.

Exceptions can be thrown by the web application frameworks and 3rd party libraries you are using. In a Seam application, those frameworks would typically include JSF, Facelets, Hibernate, and of course Seam and any of its integration modules. There are many exceptions that are obvioulsy related to bugs in your application, for these you might want to encourage the users to report these with a nice message. But you also have other exceptions, such as database lock acquisition failures, that indicate an overloaded system, which does not necessarily require a bug report.

Finally, you have your own error handling in your web application. You use (runtime) infrastructure exceptions to indicate fatal error conditions which should be reported by users when they encounter them. You use (checked) application exceptions that are expected and are handled in your code, probably without even letting the users know that some exceptional application flow occurred behind the scenes.

Handling recoverable exceptions

Seam comes with an exception handling servlet filter that wraps its processing of a request:

(... seguir leyendo en el sitio original)

hermes: exceptions

2010-03-16T22:46:00.004+01:00

Enabling Seam exception handling

mirar seam_reference: 6.12.2. Enabling Seam exception handling

You need to disable Facelets development mode in web.xml and Seam debug mode in
components.xml if you want your exception handlers to fire

--------

Las excepciones que sean gordas las podemos redirigir desde la misma excepción:

@Redirect(viewId="/failure.xhtml", end=true)
@ApplicationException
public class UnrecoverableApplicationException extends RuntimeException { ... }

Esta excepción hace que se redirija siempre que se propague fuera de la capa de componentes Seam. Asímismo finaliza la conversación.

-----

hay que declarar en el components.xml:

<core:resource-loader>
<core:bundle-names>
<value>messages</value>
</core:bundle-names>
</core:resource-loader>

---------

cualquiera de estas dos formas de coger los mensajes en la excepción funciona:

String msg1 = SeamResourceBundle.getBundle().getString("exception.myexception");

String msg2 = ResourceBundle.getBundle("messages", FacesContext.getCurrentInstance().getViewRoot().getLocale()).getString("exception.myexception");

-------------

En el messages.properties:

exception.message1=Eureka, dijo {0}

Esta excepción funciona:

import org.jboss.seam.core.Interpolator;
import org.jboss.seam.core.SeamResourceBundle;

public class MyException extends Exception {

@Override
public String getMessage() {

String msg1 = SeamResourceBundle.getBundle().getString(
"exception.message1");
String msg2 = Interpolator.instance().interpolate(msg1, "Arquímedes");

return msg2;
}
}

Setting an isolation level

2009-12-30T01:14:00.001+01:00

Setting an isolation level
Every JDBC connection to a database is in the default isolation level of the DBMS—
usually read committed or repeatable read. You can change this default in the
DBMS configuration. You may also set the transaction isolation for JDBC connec-
tions on the application side, with a Hibernate configuration option:
hibernate.connection.isolation = 4
Hibernate sets this isolation level on every JDBC connection obtained from a
connection pool before starting a transaction. The sensible values for this option
are as follows (you may also find them as constants in java.sql.Connection):
■ 1—Read uncommitted isolation
■ 2—Read committed isolation
■ 4—Repeatable read isolation
■ 8—Serializable isolation
Note that Hibernate never changes the isolation level of connections obtained
from an application server-provided database connection in a managed environ-
ment! You can change the default isolation using the configuration of your appli-
cation server. (The same is true if you use a stand-alone JTA implementation.)
As you can see, setting the isolation level is a global option that affects all con-
nections and transactions. From time to time, it’s useful to specify a more restric-
tive lock for a particular transaction. Hibernate and Java Persistence rely on
optimistic concurrency control, and both allow you to obtain additional locking
guarantees with version checking and pessimistic locking.

Transaction types

2009-12-30T00:39:00.003+01:00

RESOURCE-LOCAL	=>	EntityTransaction
JTA	=>	UserTransaction

Hibernate exceptions

2009-12-30T00:12:00.001+01:00

Any Hibernate operation, including flushing the persistence context, can throw a
RuntimeException. Even rolling back a transaction can throw an exception! You
want to catch this exception and log it; otherwise, the original exception that led
to the rollback is swallowed.
An optional method call in the example is setTimeout(), which takes the
number of seconds a transaction is allowed to run. However, real monitored trans-
actions aren’t available in a Java SE environment. The best Hibernate can do if
you run this code outside of an application server (that is, without a transaction
manager) is to set the number of seconds the driver will wait for a Prepared-
Statement to execute (Hibernate exclusively uses prepared statements). If the
limit is exceeded, an SQLException is thrown.

You don’t want to use this example as a template in your own application,
because you should hide the exception handling with generic infrastructure code.
You can, for example, write a single error handler for RuntimeException that
knows when and how to roll back a transaction. The same can be said about open-
ing and closing a Session. We discuss this with more realistic examples later in
the next chapter and again in chapter 16, section 16.1.3, “The Open Session in
View pattern.”
Hibernate throws typed exceptions, all subtypes of RuntimeException that help
you identify errors:
■ The most common HibernateException is a generic error. You have to
either check the exception message or find out more about the cause by
calling getCause() on the exception.
■ A JDBCException is any exception thrown by Hibernate’s internal JDBC
layer. This kind of exception is always caused by a particular SQL statement,
and you can get the offending statement with getSQL(). The internal
exception thrown by the JDBC connection (the JDBC driver, actually) is
available with getSQLException() or getCause(), and the database- and
vendor-specific error code is available with getErrorCode().
■ Hibernate includes subtypes of JDBCException and an internal converter
that tries to translate the vendor-specific error code thrown by the database
driver into something more meaningful. The built-in converter can pro-
duce JDBCConnectionException, SQLGrammarException, LockAquisition-
Exception, DataException, and ConstraintViolationException for the
most important database dialects supported by Hibernate. You can either
manipulate or enhance the dialect for your database, or plug in a SQLEx-
ceptionConverterFactory to customize this conversion.
■ Other RuntimeExceptions thrown by Hibernate should also abort a transac-
tion. You should always make sure you catch RuntimeException, no matter
what you plan to do with any fine-grained exception-handling strategy.

You now know what exceptions you should catch and when to expect them. How-
ever, one question is probably on your mind: What should you do after you’ve
caught an exception?
All exceptions thrown by Hibernate are fatal. This means you have to roll back
the database transaction and close the current Session. You aren’t allowed to con-
tinue working with a Session that threw an exception.

Usually, you also have to exit the application after you close the Session fol-
lowing an exception, although there are some exceptions (for example, Stale-
ObjectStateException) that naturally lead to a new attempt (possibly after
interacting with the application user again) in a new Session.

A history of exceptions

2009-12-30T00:07:00.001+01:00

Exceptions and how they should be handled always
end in heated debates between Java developers. It isn’t surprising that
Hibernate has some noteworthy history as well. Until Hibernate 3.x, all
exceptions thrown by Hibernate were checked exceptions, so every Hiber-
nate API forced the developer to catch and handle exceptions. This strat-
egy was influenced by JDBC, which also throws only checked exceptions.
However, it soon became clear that this doesn’t make sense, because all
exceptions thrown by Hibernate are fatal. In many cases, the best a
developer can do in this situation is to clean up, display an error message,
and exit the application. Therefore, starting with Hibernate 3.x, all
exceptions thrown by Hibernate are subtypes of the unchecked Runtime-
Exception, which is usually handled in a single location in an application.
This also makes any Hibernate template or wrapper API obsolete.

Manning.Java.Persistence.with.Hibernate.Nov.2006.pdf

Have you ever found yourself frustrated with a ClassNotFoundException?

2009-12-06T22:01:00.001+01:00

Tattletale

Have you ever found yourself frustrated with a ClassNotFoundException? Would you like to know what libraries are in your project and what they depend on? Would you like to get a full report on this stuff every time you run your ant build? If so you need to use the JBoss Tattletale project!

JBoss Tattletale is a tool that can help you get an overview of the project you are working on or a product that you depend on.

The tool will provide you with reports that can help you

Identify dependencies between JAR files
Find missing classes from the classpath
Spot if a class/package is located in multiple JAR files
Spot if the same JAR file is located in multiple locations
With a list of what each JAR file requires and provides
Verify the SerialVersionUID of a class
Find similar JAR files that have different version numbers
Find JAR files without a version number
Find unused JAR files
Identify sealed and signed JAR archives
Locate a class in a JAR file
Get the OSGi status of your project

JBoss Tattletale will recursive scan the directory pass as the argument for JAR files and then build the reports as HTML files.

JBoss Tattletale is licensed under GNU Lesser General Public License (LGPL) version 2.1 or later.

We hope that JBoss Tattletale will help you in your development tasks !

Please, visit the official JBoss Tattletale project page at http://www.jboss.org/tattletale/.

JavaBeans

2009-12-06T01:48:00.001+01:00

Javabeans may be used just like a stateless or stateful session bean. However, they do not provide the functionality of a session bean (declarative transaction demarcation, declarative security, efficient clustered state replication, EJB 3.0 persistence, timeout methods, etc).

Seam JavaBean components may be instantiated using Component.getInstance() or
@In(create=true). They should not be directly instantiated using the new operator.

Entity beans

2009-12-06T01:44:00.001+01:00

Entity beans are not usually used as JSF action listeners, but do often function as backing beans that provide properties to JSF components for display or form submission. In particular, it is common to use an entity as a backing bean, together with a stateless session bean action listener to implement create/update/delete type functionality.

Seam entity bean components may be instantiated using Component.getInstance(),
@In(create=true) or directly using the new operator.

Stateful session beans

2009-12-06T01:42:00.001+01:00

Application state that does not belong in the database should usually be held by stateful session beans. Instead of sticking information about the current
conversation directly in the HttpSession, you should keep it in instance variables of a stateful session bean that is bound to the conversation context.

Stateful session beans are often used as JSF action listener, and as backing beans that provide properties to JSF components for display or form submission.

Seam stateful session bean components may be instantiated using Component.getInstance()
or @In(create=true). They should not be directly instantiated via JNDI lookup or the new operator.

Stateless session beans

2009-12-06T01:40:00.001+01:00

Stateless session beans can be accessed concurrently as a new instance is used for each request. Assigning the instance to the request is the responsibility of the EJB3 container (normally instances will be allocated from a reusable pool meaning that you may find any instance variables contain data from previous uses of the bean).

Seam stateless session bean components may be instantiated using Component.getInstance() or @In(create=true). They should not be directly instantiated via JNDI lookup or the new operator.

El catalán es un dialecto del español

2009-12-05T03:14:00.002+01:00

definiciones:

dialecto.

(Del lat. dialectus, y este del gr. διάλεκτος).

1. m. Ling. Sistema lingüístico considerado con relación al grupo de los varios derivados de un tronco común. El español es uno de los dialectos nacidos del latín.

2. m. Ling. Sistema lingüístico derivado de otro, normalmente con una concreta limitación geográfica, pero sin diferenciación suficiente frente a otros de origen común.

3. m. Ling. Estructura lingüística, simultánea a otra, que no alcanza la categoría social de lengua.

lengua.

(Del lat. lingua).

1. f. Órgano muscular situado en la cavidad de la boca de los vertebrados y que sirve para gustación, para deglutir y para modular los sonidos que les son propios.

2. f. Sistema de comunicación verbal y casi siempre escrito, propio de una comunidad humana.

3. f. Sistema lingüístico cuyos hablantes reconocen modelos de buena expresión. La lengua de Cervantes es oficial en 21 naciones

4. f. Sistema lingüístico considerado en su estructura.

5. f. Vocabulario y gramática propios y característicos de una época, de un escritor o de un grupo social. La lengua de Góngora La lengua gauchesca

idioma.

(Del lat. idiōma, y este del gr. ἰδίωμα, propiedad privada).

1. m. Lengua de un pueblo o nación, o común a varios.

catalán, na.

1. adj. Natural de Cataluña. U. t. c. s.

2. adj. Perteneciente o relativo a este antiguo principado, hoy comunidad autónoma de España.

3. m. Lengua romance vernácula que se habla en Cataluña y en otros dominios de la antigua Corona de Aragón.

castellano, na.

(Del lat. Castellānus).

1. adj. Natural de Castilla. U. t. c. s.

2. adj. Perteneciente o relativo a esta región de España.

3. adj. Dicho de una gallina: De cierta variedad negra muy ponedora.

4. m. Lengua española, especialmente cuando se quiere introducir una distinción respecto a otras lenguas habladas también como propias en España.

5. m. Dialecto románico nacido en Castilla la Vieja, del que tuvo su origen la lengua española.

6. m. Variedad de la lengua española hablada modernamente en Castilla la Vieja.

español, la.

(Del prov. espaignol, y este del lat. mediev. Hispaniŏlus, de Hispania, España).

1. adj. Natural de España. U. t. c. s.

2. adj. Perteneciente o relativo a este país de Europa.

3. m. Lengua común de España y de muchas naciones de América, hablada también como propia en otras partes del mundo.

a favor:

en contra:

hsqldb

2009-12-04T03:55:00.004+01:00

para instalar y gestionar bases de datos hsqldb:

1.- bajar hsqldb de su web
2.- descomprimir en c:\hsqldb
3,. ejecutar

java -cp lib/hsqldb.jar org.hsqldb.Server -database.0 file:mydb -dbname.0 xdb

4.- ejecutar desde demo:

runManagerSwing.bat

5.- conectar mediante el wizard del manager (jdbc:hsqldb:hsql://localhost/xdb)
6.- generar el esquema ejecutando:

CREATE SCHEMA ROOT AUTHORIZATION dba;
SET SCHEMA ROOT;
CREATE USER root PASSWORD root ADMIN;

7.- crear las tablas como por ejemplo:

create table MESSAGES (
MESSAGE_ID bigint generated by default as identity (start with 1),
MESSAGE_TEXT varchar(255),
NEXT_MESSAGE_ID bigint,
primary key (MESSAGE_ID)
);

alter table MESSAGES
add constraint FK131AF14C3CD7F3EA
foreign key (NEXT_MESSAGE_ID)
references MESSAGES;

8.- Desde el HSQL Manager seleccionamos Schemas -> HERMES

hibernate3:hbm2ddl

2009-12-03T23:04:00.004+01:00

hibernate3:hbm2ddl

la solución más fácil para lo del esquema en hsqldb es crear el esquema a mano desde HSQLDB database manager
otra solución sencilla puede ser definir el esquema en orm.xml y eliminarlo de las entities (lo que ponga en el orm.xml sobreescribe lo que ponga en anotaciones)
la solución óptima parece ser eliminar @Table de las entities y declarar el default_schema en persistence.xml, en hibernate.properties y/o en hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_1_0.xsd"
version="1.0">

<persistence-unit-metadata>
<persistence-unit-defaults>
<schema>hermes</schema>
</persistence-unit-defaults>
</persistence-unit-metadata>

</entity-mappings>
la solución más elegante, aunque mucho más complicada, es aplicar los parches a:

src/org/hibernate/dialect/Dialect.java
src/org/hibernate/dialect/HSQLDialect.java
src/org/hibernate/cfg/Configuration.java

Palestina: región o estado

2009-11-30T04:36:00.003+01:00

fuente: http://www.mgar.net/africa/israel.htm

El plan de las Naciones Unidas (1947):

...Contemplaba la división de Palestina en dos países independientes

...Hasta el punto de que éstos, ante la imposibilidad de resolver un problema cada vez más enrevesado, recurrieron a las Naciones Unidas, que en célebre reunión del 19 de noviembre de 1947 decidió la partición de Palestina en dos Estados: uno israelí y otro árabe con una zona internacional para Jerusalén. Poco después se proclamaría la independencia del Estado judío el 15 de mayo de 1948, con la huida masiva de palestinos de su territorio. Y la guerra que siguió, hasta 1949, permitió ampliar el espacio israelí en 5.000 kilómetros cuadrados sobre la previa partición de la ONU, incluyendo una zona muy importante de Jerusalén. La Palestina árabe quedó sometida a sendos despojos, la franja de Gaza y de Cisjordania.(Ramón Tamames)

Palestina: un Estado ocupado, un pueblo masacrado.

...para que devuelvan a Palestina el status de nación libre y soberana.
El pueblo palestino quiere recuperar su patria, su libertad.

Palestina; Historia de un pais robado

Este site describe MUY BIEN la historia palestina desde el siglo XV muy detalladamente

sites que defienden la idea de que no ha existido nunca un estado palestino:

http://www.elimparcial.es/contenido/13682.html

De llegar a nacer, habría sido creado el primer país palestino en la historia pues, a diferencia de Israel, nunca antes ha constituido un Estado, si bien ha sido dominado por diferentes imperios como el romano, el turco otomano o, más tarde, el británico. Palestina nunca ha constituido una entidad por sí misma.

IBM WebSphere Application Server for Developers

2009-11-29T06:01:00.001+01:00

IBM WebSphere Application Server 7 for Developers

WebSphere Application Server for Developers - Now downloadable, No charge

Want to try out WebSphere Application Server V7.0 for development? Check!
Want to do it without having to order a CD? Check!
Want to do it without having to work with purchasing? Check!
Want to do it by yourself as a developer? Double Check!

I talk to many developers who want to install WebSphere Application Server for development, but every license is tracked and installed by their operations team on some remote server. Working with the operations team and (gasp) purchasing would take more time than the time to write the application they wanted to write. So they go off and download some other runtime and later port the application back to WebSphere Application Server or abandon the project altogether.

This won't be the story after today. Go here to download a no-charge copy of WebSphere Application Server for your development needs.

From the download page:

Download WebSphere Application Server for Developers, a no-charge offering that satisfies the need for a no-cost WebSphere Application Server development runtime for projects that don't warrant the expense of a priced and supported runtime on the developer desktop. Reduce testing effort and develop with confidence using a runtime environment that is identical to the production runtime environment your applications will eventually run on.

proyecto base para hermes con seam 2.2.0.GA y JBoss AS 5.1

2009-11-29T03:08:00.001+01:00

El ejemplo Seam 2.2 Booking Example -(EAR including a tutorial) que podemos bajar desde eclipse nos puede servir de base para migrar hermes a seam 2.2.0, puesto que funcionan los test a la primera.

Sólo hay que cambiar el servidor a JBoss AS 5.1 y seam a 2.2.0.GA

Using Maven, Eclipse and JBoss Tools

2009-11-29T01:15:00.001+01:00

Using Maven, Eclipse and JBoss Tools

Para usar el template de proyectos seam mavenizados con eclipse

(muestra cómo configurar eclipse con UTF-8 en MUCHAS preferencias)

A Mavenized Seam Project Template

2009-11-29T00:25:00.000+01:00

A Mavenized Seam Project Template

Know IT Objectnet developers have created a Mavenized Seam project template. Due to the lack of Maven support in the Seam project, we felt the need to get a project started for the topic. After some research and development, the base was ready to be put in use. We felt that it was only right to make the project available to the public, and put together a google code project. As of now the project is aimed at running on the JBoss-4.2.3 and JBoss-5.x application servers deployed as an EAR project.

We welcome fellow Seam + Maven fans to this project. Whether you want to use this template to develop your own projects, or you want to contribute to the project, we invite you to check out the code.

To get started check out this tutorial

Manejar Proyectos J2EE

2009-11-26T03:20:00.001+01:00

Manejar Proyectos J2EE

1 . Introducción
2 . Elegir
3 . Colaboración del Equipo
3.1 . El Respositorio de Proyecto de Maven
3.2 . El Modelo de Objeto de Proyecto (POM) de Maven
4 . Obtener Feedback del Proyecto
4.1 . Utilizar CruiseControl con Maven
5 . Manejar el Ciclo Construir/Desplegar con un sólo Click
6 . Desarrollar Varios Proyectos
7 . Empaquetar un Proyecto J2EE
8 . Tutorial de Manejo de Código
8.1 . Iniciar el Proyecto
8.2 . El Plug-in genapp de Maven
8.3 . El Plug-in JDeveloper de Maven
8.4 . Ejecutar Maven desde dentro de JDeveloper
8.5 . La Consola Maven
9 . Sumario
10 . Próximos Pasos

Hacer un merge entre dos ramas de SVN

2009-11-26T03:15:00.000+01:00

No es la primera vez que me enfrento a ello, pero siempre se me olvida cómo se hace y pierdo un montón de tiempo con ello. Así que lo apunto:

El escenario son 2 rama: el trunk y un branch del primero. El branch se creó en el día D, y en la revisión 100 (esto es importante!, mirad el log del svn si no lo sabéis). Hoy, trunk está en la revisión 400. El objetivo es mover todos los desarrollos de la branch a trunk.

1. Lo primero que hay que hacer es sincronizar todos los cambios de branch y trunk, y asegurarse que nadie trabaja en branch
2. Se baja la última versión de trunk, y no se modifica!
3. Se selecciona el proyecto trunk, y se pulsa en Team/Merge…
4. En el campo From se elige el proyecto Trunk en la revisión 100 (cuando se creó el branch!)
5. En el campo To se elige el proyecto Branch, en la HEAD revision
6. Ejecutar un DryRun. Esto simula el merge y así se puede ver si vamos bien o no
7. Ejecutar el Merge
8. Revisar todos los conflictos, los ficheros que se han borrado del trunk (aparecerán como nuevos, con el ? de svn). Borrarlos definitivamente, o no.

Y bueno, ahora volver a hacer un syncronize y un commit a ver que conflictos encontramos

deploying JEE5 apps on Websphere

2009-11-25T15:30:00.003+01:00

Integrating WebSphere EJB Deploy Ant Task with Maven 2

by Peter Pilgrim

Maven 2.0 has a valuable plug-in called maven-ejb-plugin, which creates an EJB-JAR file from a series of classes and resources. Unfortunately maven-ejb-plugin, since it is open source, does not know to build proprietary skeletons and stubs for commercial application server. In other words it does not compile or generate EJB application server specific artifacts. For Websphere this means running a specific EJB compiler. Compare this behaviour directly with the Ant EJB doclet task. How does one intercept the workings of the maven-ejb-plugin such that we can instrument EJB JAR with the Websphere EJB compiler?

Maven 2 and WebSphere - automated build and deployment of J2EE applications

muestra los pom.xml COMPLETOS para EJB, WAR, EAR y parent, partiendo del link anterior de Peter Pilgrim

WAS6 maven plugin

TODO: probar una aplicación JEE5 simple, sin Seam, desplegarla en WAS7 y correrla

This plugin can be used to

Generate EJB stub code
Generate or modify resource descriptor
Deploy EARs to targets (servers and/or clusters)
Start/stop applications
Start/stop targets (servers and/or clusters).
Execute arbitrary scripts controlling WAS environments.
Generate EAR files suitable for deploying into a WebSphere Process Server environment using ServiceDeploy.

Developing Rich Internet Applications for WebSphere Application Server Community Edition

quizás pueda servir de ejemplo

Seam 2.2.0.GA JEE5 application running on WAS7

2009-11-23T23:23:00.002+01:00

seam_reference.pdf => Chapter 40: Seam on IBM's Websphere AS

(TODO: maven2 deploy on WAS7)

persistencia y transacciones

2009-10-28T22:19:00.004+01:00

http://www.jboss.org/ejb3/docs/reference/build/reference/en/html/hibernate.html#d0e314

5.1. Hibernate Mapping Files

Persistent classes that are mapped using Hibernate .hbm.xml files are supported. The EJB3 Deployer will search the archive for any .hbm.xml files and add them to the definition of the underlying Hibernate SessionFactory. These .hbm.xml files can be virtually anywhere within the archive under any java package or directory.

Class Mappings defined in .hbm.xml files can be managed by EntityManagers just as annotated @Entity beans are. Also, you are allowed to have relationships between a .hbm.xml mapped class and an EJB3 entity. So, mixing/matching is allowed.

5.2. Injection Hibernate Session and SessionFactory

You can inject a org.hibernate.Session and org.hibernate.SessionFactory directly into your EJBs just as you can do with EntityManagers and EntityManagerFactorys. The behavior of a Session is just the same as the behavior of an injected EntityManager. The application server controls the lifecycle of the Session so that you do not have to open, flush, or close the session. Extended persistence contexts also work with injected Hibernate Sessions.

import org.hibernate.Session;
import org.hibernate.SessionFactory;

@Stateful public class MyStatefulBean ... {
 @PersistenceContext(unitName="crm") Session session1;
 @PersistenceContext(unitName="crm2", type=EXTENDED) Session extendedpc;
 @PersistenceUnit(unitName="crm") SessionFactory factory;
     
}

5.3. Access to org.hibernate.Session

You can get access to the current underlying Hibernate Session by typecasting your reference to EntityManager.

 @PersistenceContext EntityManager entityManager;
     public void someMethod();
     {
       org.jboss.ejb3.entity.HibernateSession hs = (HibernateSession)entityManager;
       org.hibernate.Session session = hs.getHibernateSession();
     }

5.4. Access to org.hibernate.Query

You can get access to the current underlying Hibernate Query by typecasting your reference to a org.hibernate.ejb.QueryImpl.

 @PersistenceContext EntityManager entityManager;
     public void someMethod();
     {
       javax.persistence.Query query = entityManager.createQuery(...);
       org.hiberante.ejb.QueryImpl hs = (QueryImpl)query;
       org.hibernate.Query hbQuery = hs.getHibernateQuery();
     }

programmatic persistence properties in JPA

2009-10-28T20:52:00.000+01:00

JPA also supports programmatic configuration, with a map of options:

Map myProperties = new HashMap();
myProperties.put("hibernate.hbm2ddl.auto", "create-drop");
EntityManagerFactory emf =
Persistence.createEntityManagerFactory("helloworld", myProperties)

Custom programmatic properties override any property you’ve set in the persis-
tence.xml configuration file.

persistencia y transacciones

2009-10-28T20:49:00.001+01:00

otra forma de establecer los boundaries de una transacción en JPA:

package hello;
import java.util.*;
import javax.persistence.*;
public class HelloWorld {
public static void main(String[] args) {
// Start EntityManagerFactory
EntityManagerFactory emf =
Persistence.createEntityManagerFactory("helloworld");
// First unit of work
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
Message message = new Message("Hello World");
em.persist(message);
tx.commit();
em.close();
// Second unit of work
EntityManager newEm = emf.createEntityManager();
EntityTransaction newTx = newEm.getTransaction();
newTx.begin();
List messages = newEm
.createQuery("select m from Message m
➥ order by m.text asc")
.getResultList();

System.out.println( messages.size() + " message(s) found" );
for (Object m : messages) {
Message loadedMsg = (Message) m;
System.out.println(loadedMsg.getText());
}
newTx.commit();
newEm.close();
// Shutting down the application
emf.close();
}
}

persistencia y transacciones

2009-10-28T20:46:00.001+01:00

These are your primary programming interfaces in Java Persistence:

■ javax.persistence.Persistence—A startup class that provides a static method for the creation of an EntityManagerFactory.

■ javax.persistence.EntityManagerFactory—The equivalent to a Hibernate SessionFactory. This runtime object represents a particular persistence unit. It’s thread-safe, is usually handled as a singleton, and provides methods for the creation of EntityManager instances.

■ javax.persistence.EntityManager—The equivalent to a Hibernate Session. This single-threaded, nonshared object represents a particular unit of work for data access. It provides methods to manage the lifecycle of entity instances and to create Query instances.

■ javax.persistence.Query—This is the equivalent to a Hibernate Query.
An object is a particular JPA query language or native SQL query representation, and it allows safe binding of parameters and provides various methods for the execution of the query.

■ javax.persistence.EntityTransaction—This is the equivalent to a Hibernate Transaction, used in Java SE environments for the demarcation of RESOURCE_LOCAL transactions. In Java EE, you rely on the standardized javax.transaction.UserTransaction interface of JTA for programmatic transaction demarcation.

persistencia y transacciones

2009-10-28T16:05:00.003+01:00

otra forma de establecer los boundaries de la transacción:

package hello;
import java.util.*;
import org.hibernate.*;
import persistence.*;
public class HelloWorld {
public static void main(String[] args) {
// First unit of work
Session session =
HibernateUtil.getSessionFactory().openSession();
Transaction tx = session.beginTransaction();
Message message = new Message("Hello World");
Long msgId = (Long) session.save(message);
tx.commit();
session.close();
// Second unit of work
Session newSession =
HibernateUtil.getSessionFactory().openSession();
Transaction newTransaction = newSession.beginTransaction();
List messages =
newSession.createQuery("from Message m order by
➥ m.text asc").list();
System.out.println( messages.size() +
" message(s) found:" );
for ( Iterator iter = messages.iterator();
iter.hasNext(); ) {
Message loadedMsg = (Message) iter.next();
System.out.println( loadedMsg.getText() );
}
newTransaction.commit();
newSession.close();
// Shutting down the application
HibernateUtil.shutdown();
}
}

sacado del chapter2.pdf del libro de hibernate (pag.47)

Test: trucos para acceder a recursos en los test

2009-10-28T15:53:00.003+01:00

(sacado del ejemplo de hibernate caveatemptor-jpa-061211)

testsuite-integration-ejb3.xml:

<parameter name="jndi_datasource" value="java:/caveatemptorTestingDatasource">


<parameter name="jndi_name_emf" value="java:/EntityManagerFactories/caveatEmptorEMF">


<parameter name="jndi_name_usertx" value="UserTransaction">

HIBERNATE: Para que solamente detecte las anotaciones

2009-10-28T15:44:00.003+01:00

En el persistence.xml:

<!-- Only scan and detect annotated entities -->
<property name="hibernate.archive.autodetection" value="class">

(sacado del ejemplo de hibernate caveatemptor)

Hibernate - Cascade recommendations

2009-10-18T21:39:00.000+02:00

Recommendations:

It doesn't usually make sense to enable cascade on a @ManyToOne or @ManyToMany association. Cascade is often useful for @OneToOne and @OneToMany associations.
If the child object's lifespan is bounded by the lifespan of the parent object, make the parent a full lifecycle object by specifying CascadeType.ALL and org.hibernate.annotations.CascadeType.DELETE_ORPHAN (please refer to the Hibernate reference guide for the semantics of orphan delete)
Otherwise, you might not need cascade at all. But if you think that you will often be working with the parent and children together in the same transaction, and you want to save yourself some typing, consider using cascade={PERSIST, MERGE}. These options can even make sense for a many-to-many association.

Hibernate - Query Hints

2009-10-18T21:12:00.002+02:00

3.4.1.7. Query hints

Query hints (for performance optimization, usually) are implementation specific. Hints are declared using the query.setHint(String name, Object value) method, or through the @Named(Native)Query(hints) annotation Note that these are not SQL query hints! The Hibernate EJB3 implementation offers the following query hints:

Table 3.1. Hibernate query hints

Hint	Description
org.hibernate.timeout	Query timeout in seconds ( eg. new Integer(10) )
org.hibernate.fetchSize	Number of rows fetched by the JDBC driver per roundtrip ( eg. new Integer(50) )
org.hibernate.comment	Add a comment to the SQL query, useful for the DBA ( e.g. new String("fetch all orders in 1 statement") )
org.hibernate.cacheable	Whether or not a query is cacheable ( eg. new Boolean(true) ), defaults to false
org.hibernate.cacheMode	Override the cache mode for this query ( eg. CacheMode.REFRESH )
org.hibernate.cacheRegion	Cache region of this query ( eg. new String("regionName") )
org.hibernate.readOnly	Entities retrieved by this query will be loaded in a read-only mode where Hibernate will never dirty-check them or make changes persistent ( eg. new Boolean(true) ), default to false
org.hibernate.flushMode	Flush mode used for this query
org.hibernate.cacheMode	Cache mode used for this query

The value object accept both the native type or its string equivalent (eg. CaheMode.REFRESH or “REFRESH”). Please refer to the Hibernate reference documentation for more information.

teresa forcades - confabulación gripe A

2009-10-09T22:02:00.002+02:00

El afán de protagonismo de la religiosa Teresa Forcades la lleva a fomentar el alarmismo sobre la Gripe A

Una reflexión y una propuesta en relación a la nueva gripe

When a pandemic isn't a pandemic

Extraits du corriel

Deploying custom resources

2009-09-27T12:31:00.005+02:00

creamos un nuevo action:

public void action1_(){
ResourceBundle bundle = SeamResourceBundle.getBundle();
String sql = bundle.getString("sql1");

log.info("sql: " + sql);
statusMessages.add("sql: " + sql);
}

y ponemos el sql.properties en el directorio src/hot:

sql1=select h from Hotel h where h.name like '%#{exampleHotel.name}%'

from http://seamframework.org/Community/IncludingAResourceBundleNotCalledMessages

<core:resource-loader>
<core:bundle-names>
<value>mycompany_messages</value>
</core:bundle-names>
</core:resource-loader>

from seam reference 2.1.1-GA.pdf

29.10. Deploying custom resources (externalizar SQL's)

Se trata de crear un componente que se cargue en el arranque de la aplicación, y contenga un set de properties con las sql's de la aplicación, y que se pueda desplegar en caliente por si se actualiza el fichero de properties.

24.2.1. Using the Hibernate API

2009-09-21T23:52:00.000+02:00

24.2.1. Using the Hibernate API

To use the Hibernate API to manage the database objects, we inject a Hibernate Session in-
stead of an EntityManager into the ManagerPojo class. The API methods in the Hibernate
Session is roughly equivalent to methods in the EntityManager; they have only slightly dif-
ferent method names. This is the Hibernate version of the ManagerPojo class:

@Name("manager")
@Scope (APPLICATION)
public class ManagerPojo {
@In (required=false) @Out (required=false)
private Person person;
@In (create=true)
private Session helloSession;
Long pid;
@DataModel
private List fans;
@DataModelSelection
private Person selectedFan;
public String sayHello () {
helloSession.save (person);
return "fans";
}
@Factory("fans")
public void findFans () {
fans = helloSession.createQuery(
"select p from Person p")
.list();
}
public void setPid (Long pid) {
this.pid = pid;
if (pid != null) {
person = (Person)
helloSession.get(Person.class, pid);
} else {
person = new Person ();
}
}
public Long getPid () {
return pid;
}
public String delete () {
Person toDelete =
(Person) helloSession.merge (selectedFan);
helloSession.delete( toDelete );
findFans ();
return null;
}
public String update () {
return "fans";
}
}

Display Error Messages on the Web Form

2009-09-21T23:16:00.001+02:00

10.4. Display Error Messages on the Web Form

s:decorate>
f:facet name="beforeInvalidField">
h:graphicimage src="anotherError.gif">
/h:graphicimage>
f:facet name="afterInvalidField">
s:message styleclass="anotherError">
/s:message>
f:facet name="aroundInvalidField">
s:span styleclass="error">
/s:span>
h:inputtext value="#{person.name}">
/h:inputtext>/f:facet>/f:facet>/f:facet>/s:decorate>

exception management in pages.xml

2009-09-21T22:37:00.002+02:00

14.4., “Use pages.xml for System
Exceptions”

from booking example:

pages.xml

You must be logged in to use this feature

Session expired, please log in again

Annotate exceptios

2009-09-21T21:14:00.003+02:00

From the book 'JBoss Seam Simplicity and Power Beyond Java EE':

14.3 Annotate Exceptions

@ApplicationException(rollback=true)
@Redirect(viewId="/inventoryError.xhtml")
public class InventoryException
extends Exception {
public InventoryException () { }
}

14.4. Use pages.xml for System Exceptions

SVN hooks for hudson builds

2009-09-21T00:55:00.007+02:00

En el directorio hooks del repositorio renombramos/copiamos post-commit.bat (o .exe)

en el fichero post-commit.bat escribimos:

python C:\svnrepos\notify_hudson.py

escribir este script en un fichero llamado notify_hudson.py:

import urllib, urllib2, time

url = 'http://localhost:8080/hudson/job/seam4hudson/build?token=build&cause=svncommit+texto'

values = {'token' : 'build', #write ur specific key/value pair
'key2' : 'value2',
'key3' : 'value3',
}

try:
# data = urllib.urlencode(values)
req = urllib2.Request(url)
response = urllib2.urlopen(req)
the_page = response.read()
print the_page
except Exception, detail:
print "Err ", detail

script sacado de http://love-python.blogspot.com/2008/04/get-content-html-source-of-url-by-http.html

maven release version plugin

2009-07-24T23:25:00.001+02:00

Para modificar las versiones de los pom.xml y sus hijos:

=======

http://stackoverflow.com/questions/415764/hierarchy-of-maven-projects-without-scattering-the-version-number
I think this approach can be complemented with Maven version plug-in: mojo.codehaus.org/versions-maven-plugin It can increment the parent.version tag in child projects automatically; see versions:update-child-modules goal. – Dan May 13 at 16:38

=======

Versions Maven Plugin

=======

Maven Release Plugin

=======

Taylor 1.3.0 - Writing Custom Generators

2009-07-09T22:18:00.001+02:00

Writing Custom Generators

From Taylor

Taylor MDA comes with a set of code generation templates. But you may want to write your own templates for any number of reasons:

You want to use a different language: Ruby, PHP, .Net, etc
You want to use a different framework: Seam vs Spring, JSF vs GWT, etc
You simply want the code to generate different
Etc...

If you just want to fix a bug you can override a template: Customize Code Templates

The following outlines how to create your own code generator plugin. These are sometime called cartridges.

[hide]

[edit]

Plugin Basics

For starters, code generators are just Eclipse plugins, so here is a good primer:

Plug-in development 101, Part 1: The fundamentals

[edit]

Create Plugin

Start by creating a basic plugin project.
1. Copy net.taylor.mda.samplegen to get a jump start.
Modify the MANIFEST.MF to match the project name, package and version.
Modify the PLUGIN_ID in the GeneratorPlugin class.
Build the plugin

Here is the basic layout of a plugin:

project
- src
  - net.taylor.mda.mygen.GeneratorPlugin
  - net.taylor.mda.generator.template.*
- templates
  - main
    - java
    - resources
  - maven
  - test
    - java
    - resources
  - Header.jetinc
- META-INF
  - MANIFEST.MF
- plugin.xml
- build.properties
- .jetproperties
- .classpath
- .project

NOTE: By convention the template directory mimics the structure of the generated code. For example, src/main/java, src/main/resources, src/test/java, src/test/resources

[edit]

Create Template

If you are new to JET, you will want to review and refer back to these tutorials:

The sample generator plugin contains a sample template.

Use the JET editor (included with taylor) to test the sample template

You will need to register it with *.*jet extensions

Here are the highlights of a template:

Name template files with an informational extensions such as: *.javajet, *.xmljet, *.xhtmljet
The first line of the template defines the class name and the imports.
The second line defines the type of UML element that is passed as an argument to the template.

<%@ jet package="net.taylor.mda.generator.template.main.java.sample" class="SampleGen"
imports="org.eclipse.uml2.uml.* java.util.* net.taylor.mda.generator.util.* org.eclipse.emf.codegen.util.*"
%>
<%Model uml2Package = (Model) argument;%>

This code handles formatting imports for java code. Imports are adding implicitly based on the UML model. Framework imports are added explicitly as shown below.

<%ImportManager importManager=null;%>
<%if (NameHelper.getQualifiedName(uml2Package) != null) {%>
<%importManager = ImportHelper.makeImportManager(NameHelper.getQualifiedName(uml2Package));%>
<%} else {%>
<%importManager = ImportHelper.makeImportManager("");%>
<%}%>
<%importManager.addImport("java.io.Serializable");%>
<%importManager.addImport("org.jboss.seam.ScopeType");%>
<%importManager.addImport("org.jboss.seam.annotations.Logger");%>
<%importManager.addImport("org.jboss.seam.annotations.Name");%>
<%importManager.addImport("org.jboss.seam.annotations.Observer");%>
<%importManager.addImport("org.jboss.seam.annotations.Scope");%>
<%importManager.addImport("org.jboss.seam.log.Log");%>

<%
StringBuffer importStringBuffer = stringBuffer;
int importInsertionPoint = stringBuffer.length();
importManager.addCompilationUnitImports(stringBuffer.toString());
%>

...

<%importStringBuffer.insert(importInsertionPoint, importManager.computeSortedImports());%>

This block shows an example of generating java code.
Various helper classes are available in package net.taylor.mda.generator.util.

<%@ include file="../../Header.jetinc"%>
package <%=NameHelper.getQualifiedName(uml2Package)%>;

...

/**
* <%=TypeHelper.getDocumentation(uml2Package)%>
*
* @author <%=System.getProperty("user.name")%>
* @generated
*/
@Name("<%=NameHelper.getUncapName(uml2Package)%>Init")
@Scope(ScopeType.APPLICATION)
public class <%=NameHelper.getCapName(uml2Package)%>Init implements Serializable {

 /** @generated */
 @Logger
 private Log log;

 /** @generated */
 @Observer("org.jboss.seam.postInitialization")
 public void init() throws Exception {
  log.info("Starting <%=NameHelper.getCapName(uml2Package)%>Init...");
 }
}

[edit]

Register Template

This is the part that is uniquely Taylor.

Each template is registered in its plugin.xml file using the template extension point. The engine in the Generator plugin uses these extensions to determine which templates to execute and how to render the menus.

                  id="EntityClass"
            path="/main/java/entity/EntityClass.javajet"
            outputPattern="/src/main/java/{0}/{1}.java"
            ifExists="merge"
            projectSuffix="jpa"
            hasStereotype="javax.persistence.Entity"
            modelElement="org.eclipse.uml2.uml.internal.impl.ClassImpl">

id - a unique name that will be used to reference this template
path - the relative location and name of the template
modelElement - what UML type does the template apply to
hasStereotype - further restrict matches based on an applied stereotype
outputPattern - describes the generated file name and path with substitutions
- {0} - path based on UML Package
- {1} - name of UML element
- {2} - name of parent UML element
- {3} - fully qualified UML element name with '::' replaced with '-'
- {4} - lower case model name with '_' replaced with '.'
- {5} - model name with '_' replaced with '.'
ifExists - what to do if the file already exists: merge, skip, backup
projectSuffix - files are generated in project named -, a new project is created if it doesn't exist

See the existing template plugins as examples.

[edit]

Test Template

We already used the JET Editor preview tab to unit test a template. Now we need to test that the template is properly registered.

Run the plug-in project as an Eclipse Application from the tool bar.
Create a test model
Test the Generate menu to verify that you template appears (see Generate Code)
Now Generate and validate the results

You will likely want to install the EMF and UML2 SDKs for debugging.
The Engine will also log exceptions to the console.
Plugging errors will show up in the Eclipse Error Log view.

That is basically it!

The following are some optional topics.

[edit]

Profiles

Taylor comes with many profiles. However, you may want to create your own for a specific framework or specification.

If you are new to UML Profiles, you will want to review and refer back to this tutorial:

Introduction to UML2 Profiles

You can reverse engineer a profile from a jar that contains annotations.

File > Import > Taylor > Import Java Annotations to UML Profile

Package the profile in a plug-in, such as the one with the templates.

Adding the following extensions to the plugin.xml will automatically add the profile to any new models.

  
         source="pathmap://MY_PROFILES/"
      target="platform:/plugin/my.plugin.profiles/profiles/">
   
 

 
         id="pathmap://MY_PROFILES/my.profile.uml"/>

See plug-in net.taylor.mda.profiles for examples.

[edit]

Utility Actions

You often need to make mass changes to a model such as spinning through all the elements and adding various stereotypes. This saves time and improves consistency.

This is accomplished using the standard Eclipse action menu mechanism. Package these actions in a plugin along side your templates and profiles.

See the net.taylor.mda.jpagen plug-in for examples.

The following example shows how to register the utilities in a plugin.xml file to be applied to a particular type of UML element.

           point="org.eclipse.ui.navigator.viewer">
                viewerId="net.taylor.mda.ModelNavigator">
        
            
        
     
  

          point="org.eclipse.ui.navigator.navigatorContent">
                    id="net.taylor.mda.jpagen.actions.AddEnumerationAction"
           class="net.taylor.mda.jpagen.actions.AddEnumerationActionExtension">

See the Eclipse Documentation for details.

Taylor 1.3.0-building the plugins

2009-07-09T22:17:00.001+02:00

Taylor 1.3.0

Building the plugins

Building the Plug-ins

Start by creating a dedicated workspace.
Then checkout the plug-ins from SVN.
To build the plug-ins right-click on the net.taylor.mda project and select Export>Plug-in Development>Deployable features
Specify a Destination Directory, such as C:\workspaces\build, and press Finish
Copy the features and plugins directories from your build directory to your eclipse directory
Restart Eclipse with the -clean option

[edit]

Testing the Plug-ins

Follow the steps above to checkout the plug-in projects
Select the net.taylor.mda project
Go to Run>Run As>Eclipse Application or Run>Debug As>Eclipse Application

[edit]

Optional

Install the SDKs for GMF and its dependencies for debugging

estructura proyecto seam

2009-06-01T02:02:00.002+02:00

lo mejor para el nuevo proyecto es estructurarlo como los proyectos maven2:

src-main-java
src-main-resources
src-test-java
src-test-resources

maven-tomcat-plugin

2009-05-30T23:01:00.000+02:00

http://mojo.codehaus.org/tomcat-maven-plugin/deployment.html

The plugin provides various methods of deployment to Tomcat:

Deploying a WAR file
Deploying an exploded WAR directory, with an optional context.xml file
Deploying an in-place WAR directory, with an optional context.xml file
Deploying a context.xml file
Running a WAR project

maven-jboss-plugin

2009-05-30T22:10:00.002+02:00

para hacer el deploy de un proyecto maven en jboss:

http://mojo.codehaus.org/jboss-maven-plugin/usage.html

importar proyectos taylor a eclipse

2009-05-23T01:37:00.004+02:00

crear nuevo workspace

import -> maven projects from scm

Seleccionar el directorio padre de todos los proyectos (no el master). El plugin buscará todos los pom.xml en los subdiretorios y creará los proyectos

por ejemplo para el proyecto taylor-tracker-1.2.0:

http://taylor.svn.sourceforge.net/svnroot/taylor/applications/branches/taylor-tracker-1.2.0

Generar DDL con maven2

2009-05-23T00:18:00.004+02:00

En el proyecto de taylor-tracker que viene en el fichero taylor-tracker-jboss-bundle-1.2.0.zip, en la carpeta:

jboss-4.2.0.GA\server\all\deploy\taylor-tracker-app-1.2.0.ear\taylor-tracker-jpa-1.2.0.jar\META-INF\maven\taylor-tracker\taylor-tracker-jpa

está el pom.xml del artefacto. En este fichero hay un comentario que nos puede servir para facilitar la generación de la DDL a partir del proyecto jpa generado por el modelo:

create the hbm2ddl.properties file with your dialect:
hibernate.dialect=org.hibernate.dialect.Oracle9Dialect

el fichero hay que crearlo en src/test/resources/hbm2ddl.properties

generará el fichero en hibernate3/sql/schema.sql

then run: mvn hibernate3:hbm2ddl

another UML tool

2009-05-19T22:59:00.001+02:00

UML tool

http://topcased-mm.gforge.enseeiht.fr/website/modeling/uml/index.html

updatesite: http://topcased-mm.gforge.enseeiht.fr/release/update-site

puntos interesantes en seam_reference-2.1.2.CR1.pdf

2009-05-19T20:57:00.003+02:00

29.1.4.5. Character encoding

Sets the character encoding of submitted form data.

This filter is not installed by default and requires an entry in components.xml to enable it:


<web:character-encoding-filter encoding="UTF-16" override-client="true" url-pattern="*.seam"/>

encoding — The encoding to use.
override-client — If this is set to true, the request encoding will be set to whatever is specified by encoding no matter whether the request already specifies an encoding or not. If set to false, the request encoding will only be set if the request doesn't already specify an encoding. The default setting is false.

Transactions

Finally, let's talk about transactions. In an EJB3 environment, we recommend the use of a special built-in component for transaction management, that is fully aware of container transactions, and can correctly process transaction success events registered with the Events component. If you don't add this line to your components.xml file, Seam won't know when container-managed transactions end:

<transaction:ejb-transaction/>

29.4.1. Boostrapping Hibernate in Seam

Seam will bootstrap a Hibernate SessionFactory from your hibernate.cfg.xml file if you install a built-in component:


<persistence:hibernate-session-factory name="hibernateSessionFactory"/>

You will also need to configure a managed session if you want a Seam managed Hibernate Session to be available via injection.


<persistence:managed-hibernate-session name="hibernateSession"

                            session-factory="#{hibernateSessionFactory}"/>

29.4.2. Boostrapping JPA in Seam

Seam will bootstrap a JPA EntityManagerFactory from your persistence.xml file if you install this built-in component:


<persistence:entity-manager-factory name="entityManagerFactory"/>

You will also need to configure a managed persistence context if you want a Seam managed JPA EntityManager to be available via injection.


<persistence:managed-persistence-context name="entityManager"

                            entity-manager-factory="#{entityManagerFactory}"/>

persistence unit

2009-04-20T02:15:00.000+02:00

Packaging

EJB3 JPA is standardizing POJO persistence. Thus, entities aren't limited to EJB modules; they can be packaged in a Web module, ejb-jar module, library module in the EAR level, or a standard jar file. You can also use entities in Java SE. You must package a descriptor (persistence.xml), like the following, in the archive that contain entities:



oracle.toplink.essentials.PersistenceProvider
jdbc/OracleDS
...

This descriptor identifies the persistence provider, persistent units, and the data source used by a persistent unit. As the name suggests, a persistent unit is a collection of entities that are managed together. If you have a single persistent unit defined in a specific module, you don't have to identify the entity classes in the persistence.xml; it will be dynamically discovered by the persistence provider.

persist an entity (Serializable) on application-managed entity manager

2009-04-20T02:07:00.002+02:00

from Standardizing Java Persistence with the EJB3 Java Persistence API

If you persist an entity, any state changes to associated entities will be persisted as well if CascadeType for the relationship is set to PERSIST or ALL. Unless you're using an extended persistent context, the entities will become detached after the end of the transaction. The merge operation lets you merge a detached entity instance with the persistent context; the state of a detached entity will be synchronized with the database. This helps you get rid of the Data Transfer Object (DTO) anti-pattern prevalent in EJB 2.x because entities, being POJOs, can be transferred between tiers. The only requirement is that the entity class must implement the java.io.Serializable interface.

Extending the Hibernate Validation Framework for Complex Rules

2009-04-20T01:27:00.001+02:00

Extending the Hibernate Validation Framework for Complex Rules

go

The Hibernate Validation Framework leverages annotations to define data validation rules on entity beans. Out of the box it comes with many useful annotations for defining simple validation rules such as, NotNull, Min, Max, etc... However, for complex rules that involve multiple properties you will have to write your own validators. This posting shows two approaches to make this easier by using expression language and custom code fragments.

Simple Validations

Here is an example of a simple validation. The annotation on the amount property is scoped just to that property. Thus only simple rules can be defined.

@Entity
public class Loan {
@NotNull(message="The Amount must be provided.")
private Double amount;
...
}

Complex Validation

Here is an example of a complex validation. The annotation on the class is scoped to the whole class. Thus complex rules can be defined that involve any property in the class.

@Entity
@StartDateBeforeEndDate(message="The start date must be before the end date.")
public class Loan {
private Date startDate;
private Date endDate;
...
}

These features pretty much cover all the various validation requirements. However, defining complex validation rules requires writing both a custom annotation and a custom validator for each rule, which can become very cumbersome. Here are two ways around this issue.

Expression Language Validator

By using expression language we can write a generic validator that can be reused for various rules. The generic Expression annotation is used to define the rule.

@Entity
@Expression(value="value.startDate <>", message="The start date must be before the end date.")
public class Loan {
private Date startDate;
private Date endDate;
...
}

The ExpressionValidator class uses the commons-jexl library to evaluate the expression. The value variable in the expression equals the instance of the object being validated. In this case value is a loan.

public class ExpressionValidator implements Validator {
private String expression;
public void initialize(Expression expression) {
this.expression = expression.value();
}

public boolean isValid(Object value) {
org.apache.commons.jexl.Expression e = ExpressionFactory.createExpression(expression);
JexlContext jc = JexlHelper.createContext();
jc.getVars().put("value", value);
return (Boolean) e.evaluate(jc);
}
}

Custom Assertion Validator

There are times when you will just have to write custom validation code. But instead of writing a custom annotation and validator class it would be nice to encapsulate the rules in the same class for which the rules apply. This generic Assertion annotation and IAssertion interface do the trick.

@Entity
@Assertion(value=Loan.StartDateBeforeEndDateAssertion.class, message="The start date must be before the end date.")
public class Loan {
private Date startDate;
private Date endDate;
...
public static class StartDateBeforeEndDateAssertion implements IAssertion
{
public boolean isValid(Object value) {
Loan loan = (Loan) value;
return loan.getStartDate().before(loan.getEndDate());
}
}
}

The AssertionValidator class will create an instance of the IAssertion and execute it against the object being validated.

public class AssertionValidator implements Validator {
private IAssertion assertion;
public void initialize(Assertion assertion) {
this.assertion = (IAssertion) assertion.value().newInstance();
}

public boolean isValid(Object value) {
return assertion.isValid(value);
}
}

Hopefully the expression appoach will satisfy all your needs and you wont need this custom code approach. For example, you could add an isStartDateBeforeEndDate() method to your entity and call it in a simple expression as show below. But the custom code approach is here just in case.

@Entity
@Expression(value="value.startDateBeforeEndDate", message="The start date must be before the end date.")
public class Loan {
...
public boolean isStartDateBeforeEndDate() {
return startDate.before(endDate);
}
}

Multiple Rules

There is still another piece to this puzzle. We need to be able to apply multiple expressions or assertions. To do this we need a container annotation.

@Entity
@Expressions ({
@Expression(value="value.startDate <>", message="..."),
@Expression(value="...", message="...")
})
public class Loan {
private Date startDate;
private Date endDate;
...
}

Note that this capability relies on a requested Hibernate enhancement. You can vote for this enhancement here: JIRA Issue ANN-513 . Or you can apply the patch yourself.

Resources

Hibernate Validation Framework
Taylor Validation

Commons Jexl

An Agile Development Environment

2009-04-20T00:55:00.000+02:00

An Agile Development Environment

All agile methodologies preach delivering working software early and continuously. To achieve this an automated development environment is beneficial. It is also important to get a new project up and running quickly. To this end here is a suggested development environment made up of open source tools along with instructions for getting up and running.

Server Machine

Use your perfered operationing system: Linux, Windows, etc. These instructions will be some what specific to Windows.
Two gigs of RAM, a dual processor, and a fast harddrive are the minimum recommendations.
Install Java 5 or higher: http://java.sun.com/javase/downloads/index_jdk5.jsp

Source Control Management

The first thing you will need on your development server is version control. SVN is the tool of choice!

SVN 1 Click Setup is a great utility to install SVN and TortoiseSVN on windows.

Next you want to install Apache HTTP Server to access SVN remotely.

Apache HTTP Server Download
This SVN chapter shows how to point Apache to your SVN repository: Chapter 6. Server Configuration. The basics are modify your httpd.conf file to

uncomment the DAV modules
add

LoadModule dav_svn_module modules/mod_dav_svn.so

map the location

DAV svn
SVNPath c:/svnrepos

On the client machines you will need Subclipse and TortoiseSVN.

Continuously Integration Build System

Now we need to install Maven and create your own corporate maven repository.

Download Maven
Unzip to a desired location
Add the bin directory to your system path
Add the following to your httpd.conf file

Alias /maven2/ c:/WINDOWS/system32/config/systemprofile/.m2/repository/
Alias /maven2 c:/WINDOWS/system32/config/systemprofile/.m2/repository

Options Indexes
AllowOverride All
Order allow,deny
Allow from all

Next we need to install and configure Continuum to automate your builds.

Download Continuum
Unzip to a desired location
Add the following to your httpd.conf file

ProxyPass /continuum http://localhost:8091/continuum/
ProxyPassReverse /continuum http://localhost:8091/continuum/

Alias /working-directory/ c:/continuum/working-directory/
Alias /working-directory c:/continuum/working-directory/

Options Indexes
AllowOverride All
Order allow,deny
Allow from all

Note that you will need to add the and sections to all of your pom.xml files.

Database

For running junit tests the Hypersonic in memory database is excellent. It can be downloaded automatically by maven. To demo your applications to your customers MySQL is a great choice.

Download and run

mysql-essential-4.1.21-win32.msi

mysql-gui-tools-5.0-r3-win32.msi

Download and place in your app servers lib directory

mysql-connector-java-3.1.13.zip

Application Server

To get up and running fast with JBoss AS + Portal you can start with the Taylor Tracker Bundle. It is preconfigured with various JBoss components. Just unzip it to the desired location. You will want at least two servers configured: QA and PM. The QA server will be used for running all your automated test cases and for demonstration to your customer. The PM server will run various project management and collaboration software like Taylor Tracker, JBoss Wiki, and JBoss Forum, etc.

Client Tools

On the client side us Eclipse. More information is available on the Taylor Installation page.

That is pretty much it! It is also a good idea to ghost this configuration so that you can stamp out new servers as needed. And don't forget to setup a backup schedule for the SVN repository and the MySQL database.

Taylor - Model Management

2009-04-19T23:19:00.003+02:00

Model Management

In any real world application you will need to manage the size of your models so that multiple people can work on the project at the same time. This is often referred to as Team support.

[hide]

[edit]

SCM

The obvious solution is to use a Source Control Management (SCM) system such as CVS or Subversion. Taylor model files are just XMI files, so they are ready for scm. And Eclipse provides the scm infrastructure needed for checkin, checkout, diff, merge, etc...

But, scm is not enough.

[edit]

Architecture

We are really talking about an architecture problem. Not the architecture of the tool, but the architecture of your project. Is it one big jumble or is it decomposed into reasonable systems and subsystems and components and so forth.

[edit]

Tool Support

Taylor leverages all of the features provided by EMF and GMF.

There are 2 basic options:

Use multiple models and link them together
- See Resource Linking and Diagram Shortcuts
Divide one model into separate files by package
- See Controlling Packages

You will probably use some combination of both.

[edit]

Resource Linking

Right click anywhere in the Navigator and select Load Resource...
Browse the workspace for a model
Then you should be able to access the elements in the linked model from various property editors

[edit]

Diagram Shortcuts

Right click in a diagram and select Create Shortcut...
Browse to an element you want to display in the diagram

[edit]

Controlling Packages

Right click any package in the Navigator and select Control...
Select Browse Workspace and select a folder to create the new file
Name the file similar to the package name and give it a .uml extension
Then right click on the navigator and select Save to create the new file
A little green icon decoration will show that the package is controlled

Taylor

2009-04-19T22:38:00.009+02:00

Classpath

Now lets setup the classpath before browsing the code.

Open the Eclipse preferences and add a M2_REPO classpath variable that points to your Maven repository [${user.home}/.m2/repository]

Or use maven: mvn -Declipse.workspace= eclipse:add-maven-repo

Open a command window, navigate to your master project directory, and run 'mvn install' and then 'mvn eclipse:eclipse' to generate the .project and .classpath files for all of the projects.

NOTE: If this is the first time you are running this it will take a while to download all the necessary jars. You may have to repeat it several times. It will also fail when it reaches the web project, but that is OK, we will come back to that later.

If you want to use WTP with the web project then use mvn eclipse:eclipse -Dwtpversion=1.5 in the web and pdf project directories
JSF Support

Now, go back to Eclipse and switch to the Java perspective. Then select all the projects and press F5 to refresh.

Now browse the code to see what was generated. The high-lights are discussed below.

Enumerations

Also give creating an Enumeration a try. And add some Literals. Then create a status property on the entity bean with a type of Status.

Now lets run some helper utilities to make some bulk changes to the model. Right-click on the net.taylor.tutorial.entity package and select Utilities > JPA and then run:

Add Temporal Stereotypes and
Add Enumeration Stereotypes

JSF Support

This will probably be fixed in a future version of the eclipse plugin.

Add the following to .settings/org.eclipse.wst.common.project.facet.core.xml

Types to Java and JSF Mapping
NOTE: Change the type of the description property to types.Text so that a Text Area will be generated in the facelet.

String String JSF Input Text
Text String Text Area - TinyMCE Editor
Date Date Seam Date Picker
Boolean Boolean JSF Check Box
Integer Long RichFaces Spinner
Decimal Double JSF Decimal
Currency BigDecimal JSF Currency
Percentage Double JSF Percentage
Byte[] byte[] Seam File Upload
Image String JSF Image
Link String JSF Link
Enumeration your Enum JSF SelectOne
Many to One Association your Class JSF SelectOne
Double Double deprecated - use Decimal, Currency, or Percentage
Long Long deprecated - use Integer

JPA Utilities
Cleanup Associations For each association, default the mappedBy and cascade properties

Add Embedded Stereotypes
Add Temporal Stereotypes For each property of type Date, Time, or Timestamp add the stereotype and set the value accordingly.

Add Enumeration Stereotypes For each property with an Enumeration type add the stereotype and set the value to STRING

Add Index Stereotype to ManyToOne Properties
Add Join Table Stereotypes
Switch Inheritance Types
Switch Id Generators
Add Table Stereotypes
Add Column Stereotypes
Add Attribute Override Stereotypes

Unit Tests
From Taylor

Three types of JUnit tests are generated: Service, Seam, and JasperReports.

Seam
A Seam junit test is generated in the Ejb3 project for each entity. These tests verify that the Finder and Editor SFSBs and the Facelets expressions (EL) are working properly.
You might need to tweak the default values for properties.
Association tests are also not generated.
Possible Compilation Errors
After generating the code and setting up the classpath you may notice that some of the code might have compile errors. This could happen for several reasons:
Something might be missing from the model. Fix the model and regenerate.
Various TreeNode and EditorBean methods assume there is a property called 'name' that is used for display. Change these to the property you would like to display. For example, in the tutorial the Ticket entity has a 'title' property instead of a 'name' property.

You added an Interceptor from a third party that needs to be added to the Maven pom.xml dependencies section. Or you added an Interceptor that you need to implement.
The session bean operations need to be implemented because they did not match one of the default implementations: save, get, delete, query.
You defined a operation named query that does not match the default signature. See below.
This is the default signature for operations named query. You will want to define more specialized query operations for the service, but using this signature is a good way to get a prototype up and running quickly. So, either change the model or implement the query as you see fit. Another good option is to use the NamedQuery stereotype to define your queries. It is a good practice to name these the same as the operation that will use them.
public List query(SomeEntity example, Long first, Long max, String orderBy) {
}

Facelets Customization

The generated facelets are meant to be customized. Generating an
Entity bean is very straight forward because there are well defined
rules and only so many variations. On the other hand, the user
interface is the place where different applications can differentiate
themselves.

To this end, the generated facelets are meant to give you a jump start. The following sections outline possible modifications.

[edit]

Editor

For the most part the UI can be customized by making changes to the EditorBeans.

Implement isEditable()
Change the various isRendered methods
Implement isRendered(String name) and isDisabled(String name) to control individual fields
Modify Many2One and Many2Many association methods to change
what fields are displayed and add filters. See TODO tags placed in the
code.
Change createInstance() to initialize properties.
Add additional actions like submit() and schedule(). Examples have been generated.

[edit]

Finder

getSearchFields()
Add Chart methods

[edit]

Menus

The default-object.xml file defines how pages will be displayed in
JBoss Portal. You will probably want to add and remove pages from this
file. Alternatively, you can do this online in JBoss Portal.

You can also create additional *-object.xml files.

[edit]

UI Facelets

This is were you might make the most changes, such as rearranging fields, changing input types, and adding buttons.

The Facelets use the standard Portlet CSS Styles, so you can accomplish a lot by changing the Portal Theme.

Facelets templates and tags are leveraged also. When the
Web project is built for the first time the Taylor-Tags library will be
expanded into your project. You can then change the following files to
make global changes across your application:

webapp/web-inf/jsf/templates
webapp/web-inf/jsf/tags
webapp/web-inf/pdf/templates
webapp/web-inf/pdf/tags

[edit]

Report Facelets

The generated Seam PDF files are just Facelets so the same things apply as for the UI facelets.

Seam Tests

Taylor Commons contains a port of the Seam TestNG libraries to JUnit. Seam junit tests are generated for each Entity in the model to test the generated CRUD Editor and FInder classes. You will need to tweak the default values for some fields like dates and enumerations.

Version Control

Check in the model, diagrams, and generated code and descriptors into your version control system. I typically generate the code, then tweak it enough to compile, and then check it in. Then I do any major modifications and check that in before iterating again through the model and regenerating.

Package and Deploy

Setup

Download and unzip Taylor Tracker 1.1.0 JBoss Bundle. This contains JBoss with all the necessary components configured, such as EJB3 and JBoss Portal.

Copy the necessary configuration files generated in your Ear project's jboss\deploy directory to the server\all\deploy directory.
- For example, to setup a datasource copy tutorial-hsqldb-ds.xml

Setup the JBOSS_HOME system property to point to your JBoss installation
- SET JBOSS_HOME=C:\jboss-4.2.0.GA

[edit]

Build

Change directories to your master project run mvn clean install to clean, compile, test, package, and install all the sub-projects: jpa, ejb, web, pdf, app, doc, etc.

[edit]

Deploy

The App project's pom.xml has the logic to copy the Ear file to your JBoss server.

Alternatively, you can still use the jboss-maven-plugin
- Run mvn clean install jboss:harddeploy to deploy your Ear to JBoss.

[edit]

Packaging

Run mvn site to generate the project website with javadoc, xref, and test reports.

Run mvn assembly:assembly to package everything into zip and tar files.
- Make these modifications to support this.

[edit]

Other Useful Maven Plugins

The templates could be changed to generate some of these:

[edit]

Reports

[edit]

Packaging

Customize Code Templates

Templates can be overridden by placing a new version in the directory you specify under Window/Preferences/Taylor. This is useful for overriding the copy right Header template or for fixing template bugs. The templates are found in plug-ins such as net.taylor.mda.ejb3gen.

I typically do the following:

Create a templates folder next to the model folder.
Set the preferences to point to this folder.
Create a Header.jetinc file in this folder.
Check in the custom template so everyone else has access.
As the project progresses we will put additional customized templates here as well. NOTE: The path has to match the path specified in the particular plugin.xml file so that the engine finds them.

Custom Plugins

Additional templates can be added by placing them in your own plugin and adding the following extension point to its plugin.xml.

Additional information can be found under Architecture.

A good JET Template Editor can be found at http://www.eclipse.org/emft/projects/jeteditor/

Anotaciones EJB3

2009-04-19T22:31:00.004+02:00

Anotaciones en EJB 3.0

http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=AnotacionesEJB3

API de Persistencia: EntityManager

Primero veremos algunas partes importantes de la API, como la interfaz EntityManager. Esta interfaz es en la que se apoya la API de persistencia y la que se encarga del mapeo entre una tabla relacional y su objeto Java. Funcionalmente es similar a la clase Session de Hibernate o a PersistenceManager de JDO. Proporciona mé;todos para manejar la persistencia de un Bean de Entidad, permite añadir, eliminar, actualizar y consultar así como manejar su ciclo de vida. Sus métodos má;s importantes son:

persist(Object entity) - almacena el objeto entity en la base de datos.
merge(T entity) - actualiza las modificaciones en la entidad devolviendo la lista resultante.
remove(Object entity) - elima la entidad.
find(Class entity, Object primaryKey) - busca la entidad a través de su clave primaria.
flush() - sincroniza las entidades con el contenido de la base de datos.
refresh(Object entity) - refresca el estado de la entidad con su contenido en la base de datos.
createQuery(String query) - Crea una query utilizando el lenguaje JPQL.
createNativeQuery() - Crea una query utilizando el lenguaje SQL.
isOpen() - Comprueba si está; abierto el EntityManager.
close() - Cierra el EntityManager.

Podemos obtener una referencia al EntityManager a través de la anotación @PersistenceContext. El contenedor de EJB nos proporciona el contexto de persistencia mediante inyección por lo que no tendremos que preocuparnos de su creación y destrucción.

@PersistenceContext
EntityManager entityManager;

Otra forma de obtener un EntityManager es a través de la factoría EntityManagerFactory con el nombre del contexto de persistencia configurado en el persistence.xml .

EntityManagerFactory emf = Persistence.createEntityManagerFactory("TestPersistence");
EntityManager em = emf.createEntityManager();

En el método createEntityManagerFactory de la clase Persistence se debe pasar el nombre del contexto definido en el persistence.xml .

Ciclo de vida de una Entidad

Engloba dos aspectos: la relación entre el objeto Entidad y su contexto a persistir y por otro lado la sincronización de su estado con la base de datos. Para realizar estas operaciones la Entidad puede encontrarse en cualquiera de estos cuatro estados:

new - Nueva instancia de la Entidad en memoria sin que aún le sea asignado su contexto persistente almacenado en la tabla de la base de datos.
managed - La Entidad dispone de contenido asociado con el de la tabla de la base de datos debido a que se utilizó el método persist(). Los cambios que se produzcan en la Entidad se podrá;n sincronizar con los de la base de datos llamando al método flush().
detached - La Entidad se ha quedado sin su contenido persistente. Es necesario utilizar el método merge() para actualizarla.
removed - Estado después de llamarse al método remove() y el contenido de la Entidad será; eliminado de la base de datos.

Anotaciones de un Bean de Entidad

@Entity: Indica que es un Bean de Entidad.

name - por defecto el nombre de la clase pero se puede especificar otra diferente.

Métodos del ciclo de vida de una Entidad

@EntityListeners: Se pueden definir clases oyentes (listeners) con métodos de ciclo de vida de una entidad. Para hacer referencia a un listener se debe incluir esta anotación seguido entre paréntesis de la clase: @Entity Listeners(MyListener.class)

@ExcludeSuperclassListeners: Indica que ningún listener de la superclase será; invocado por la entidad ni por ninguna de sus subclases.

@ExcludeDefaultListeners: Indica que ningún listener por defecto será; invocado por esta clase ni por ninguna de sus subclases.

@PrePersist: El método se llamará; justo antes de la persistencia del objeto. Podría ser necesario para asignarle la clave primaria a la entidad a persistir en base de datos.

@PostPersist: El método se llamará; después de la persistencia del objeto.

@PreRemove: El método se llamará; antes de que la entidad sea eliminada.

@PostRemove: El método se llamará; después de eliminar la entidad de la base de datos.

@PreUpdate: El método se llamará; antes de que una entidad sea actualizada en base de datos.

@PostUpdate: El método se llamará; después de que la entidad sea actualizada.

@PostLoad: El método se llamará; después de que los campos de la entidad sean cargados con los valores de su entidad correspondiente de la base de datos. Se suele utilizar para inicializar valores no persistidos.

@FlushMode: Modo en que se ejecuta la transacción: FlushModeType.AUTO (por defecto) y FlushModeType.COMMIT.

@NamedQuery: Especifica el nombre del objeto query utilizado junto a EntityManager.

name - nombre del objeto query.
query - especifica la query a la base de datos mediante lenguaje Java Persistence Query Language (JPQL)

@NamedQueries: Especifica varias queries como la anterior.

@NamedNativeQuery: Especifica el nombre de una query SQL normal.

name - nombre del objeto query.
query - especifica la query a la base de datos.
resultClass - clase del objeto resultado de la ejecución de la query.
resultSetMapping - nombre del SQLResultSetMapping definido (se explica má;s abajo).

@NamedNaviteQueries: Especifica varias queries SQL.

@SQLResultSetMapping: Permite recoger el resultado de una query SQL.

name - nombre del objeto asignado al mapeo.
EntityResult[] entities() - entidades especificadas para el mapeo de los datos.
ColumnResult[] columns() - columnas de la tabla para el mapeo de los datos.

@NamedNativeQuery(name="nativeResult", query="SELECT NOMBRE,APELLIDOS FROM USUARIOS WHERE USUARIO_ID= 123", resultSetMapping = "usuarioNamedMapping")
             

@SqlResultSetMapping(name="usuarioNamedMapping",
entities = {

@EntityResult(entityClass = com.autentia.entidades.Usuario.class,
fields = {

@ColumnResult(name="usuarioId", column="USUARIO_ID"),

@ColumnResult(name="nombre", column="NOMBRE"),
@ColumnResult(name="apellidos", column="APELLIDOS")})})

@PersistenceContext: Objeto de la clase EntityManager que nos proporciona todo lo que necesitamos para manejar la persistencia.

name - nombre del objeto utilizado para la persistencia en caso de ser diferente al de la clase donde se incluye la anotación.
unitName - identifica la unidad de la persistencia usada en el bean en caso de que hubiera má;s de una.
type - tipo de persistencia, TRANSACTION (por defecto) | EXTENDED.

@PersistenceContexts: Define varios contextos de persistencia.

@PersistenceUnit: Indica la dependencia de una EntityManagerFactory definida en el archivo persistence.xml.

name - nombre del objeto utilizado para la persistencia en caso de ser diferente al de la clase donde se incluye la anotación.
unitName - identifica la unidad de la persistencia usada en el bean en caso de que hubiera má;s de una.

@Lob: Se utiliza junto con la anotación @Basic para indicar que un campo se debe persistir como un campo de texto largo si la base de datos soporta este tipo.

@Transactional

2009-04-14T01:51:00.000+02:00

seam_reference-2.1.1.GA.pdf line 525 (search for '@Transactional')

30.5. Annotations for use with Seam JavaBean
components in a J2EE environment
Seam provides an annotation that lets you force a rollback of the JTA transaction for certain action
listener outcomes.
@Transactional
@Transactional
Specifies that a JavaBean component should have a similar transactional behavior to the
default behavior of a session bean component. ie. method invocations should take place in
a transaction, and if no transaction exists when the method is called, a transaction will be
started just for that method. This annotation may be applied at either class or method level.
Do not use this annotation on EJB 3.0 components, use @TransactionAttribute!
@ApplicationException
@ApplicationException
Synonym for javax.ejb.ApplicationException, for use in a pre Java EE 5 environment. Applied
to an exception to denote that it is an application exception and should be reported to the
client directly(i.e., unwrapped).
Do not use this annotation on EJB 3.0 components, use
@javax.ejb.ApplicationException instead.
• rollback — by default false, if true this exception should set the transaction to rollback
only

seam transaction

2009-04-14T01:35:00.000+02:00

D:\Development\TOOLS_HOME\taylor\svn\components\branches\taylor-components-1.2.0\taylor-commons\src\test\java\net\taylor\conv\ConversionTest.java

protected void persist(EntityManager em) {
SampleEntity e = new SampleEntity();
e.setName("e1");
e.setType(Type.A);
em.persist(e);

e = new SampleEntity();
e.setName("e2");
// e.setType(Type.A);
em.persist(e);

e = new SampleEntity();
e.setName("e3");
// e.setType(Type.A);
em.persist(e);
}

seam transaction

2009-04-14T01:34:00.000+02:00

D:\Development\TOOLS_HOME\taylor\svn\applications\branches\taylor-tracker-1.2.0\ejb\src\main\java\net\taylor\tracker\web\TransactionScript.java

public Object run() {
try {
EntityManagerFactory emf = (EntityManagerFactory) lookup(persistenceUnitJndiName);
EntityManager em = emf.createEntityManager();
UserTransaction t = (UserTransaction) lookup("UserTransaction");
try {
t.begin();
em.joinTransaction();
Object o = persist(em);// do the work
em.flush();
t.commit();
return o;
} catch (Exception e) {
t.rollback();
throw e;
} finally {
em.close();
}
} catch (Exception x) {
throw new RuntimeException(x);
}
}

2009-04-14T01:33:00.000+02:00

D:\Development\TOOLS_HOME\taylor\svn\applications\branches\taylor-tracker-1.2.0\ejb\src\main\java\net\taylor\tracker\TrackerInit.java

protected void addGroup(String id, String name, String description) {
Group group = identityEntityManager.find(Group.class, id);
if (group == null) {
group = new Group();
group.setId(id);
group.setName(name);
group.setDescription(description);
identityEntityManager.persist(group);
}
}

2009-04-14T01:30:00.000+02:00

D:\Development\TOOLS_HOME\taylor\svn\applications\branches\taylor-tracker-1.1.0\ejb\src\main\java\net\taylor\tracker\web\TransactionScript.java

try {
EntityManagerFactory emf = (EntityManagerFactory) lookup(persistenceUnitJndiName);
EntityManager em = emf.createEntityManager();
UserTransaction t = (UserTransaction) lookup("UserTransaction");
try {
t.begin();
em.joinTransaction();
Object o = persist(em);// do the work
em.flush();
t.commit();
return o;
} catch (Exception e) {
t.rollback();
throw e;
} finally {
em.close();
}

Definitivo ejemplo de @ApplicationException

2009-04-07T01:31:00.002+02:00

En el ejemplo dvdstore, hay un @ApplicationException en CheckoutAction.
Está en el método submitOrder(), que tiene un @End.

Dependiendo de cierta condición lanza una InsufficientQuantityException o hace el persist:

em.persist(order);

dvdstore

2009-04-07T00:53:00.000+02:00

el proyecto dvdstore ear de los project examples funciona en jboss 4.2, con el seam eap 2.0 de jbstudio y añadiendo a mano el ds.xml

maven2 embedded dependencies

2009-04-06T23:45:00.001+02:00


     
         org.jboss.embedded
         hibernate-all
         beta3
         jar
         compile
     
     
         org.jboss.seam.embedded
         jboss-embedded-all
         beta3
         jar
         compile
     
     
         org.jboss.seam.embedded
         thirdparty-all
         beta3
         jar
         compile

Bean-managed transactions (BMT)

2009-04-02T00:08:00.000+02:00

Bean-managed transactions (BMT)—Developers should use bean-managed
transactions in order to have a finer-grained control over their transactional
system. For instance, with BMT beans, you can create more than one trans-
action per bean method (see recipe 5.9). A BMT bean is responsible for cre-
ating, propagating, committing, and rolling back its transactions. By not
relying on the container, the bean developer must face the sometimes
daunting task of coordinating a transactional system. EJB applications that
use BMT beans can be every bit as secure and reliable as CMT applications,
but there is a larger chance of developer-introduced transactional errors. In
most cases, the EJB container is sufficient for enterprise applications’ trans-
action management.

testng configuration for Seam project

2009-03-30T00:25:00.004+02:00

I'm really getting my nickers in a twist when configuring testng in eclipse.
Actually, the best approach is through Run->Debug Configurations->TestNG.

Seam fileupload samples

2009-03-18T00:56:00.000+01:00

subida de imagen

Big File Upload

Installing Embedded JBoss into Standalone Tomcat 6.0

2009-03-17T21:51:00.000+01:00

Installing Embedded JBoss into Standalone Tomcat 6.0

Embedded JBoss

2009-03-17T21:45:00.002+01:00

EJB 3.0 y pruebas unitarias
con Maven, JUnit y Embedded JBoss

1.- instalar embedded JBoss
2.- meterlo en un repositorio maven2

Hibernate exporters

2009-03-17T19:43:00.004+01:00

Hibernate exporters

4.4. Exporters

4.4.1. Database schema exporter ()

4.4.2. POJO java code exporter ()

4.4.3. Hibernate Mapping files exporter ()

4.4.4. Hibernate Configuration file exporter ()

4.4.5. Documentation exporter ()

4.4.6. Query exporter ()

4.4.7. Generic Hibernate metamodel exporter ()

4.4.7.1. Seam Exporter via

4.5. Using properties to configure Exporters

4.5.1. and

4.5.2. Getting access to user specific classes

seam fileupload

2009-03-17T16:34:00.001+01:00

http://linuxbeans.blogspot.com/2007/10/image-handling-in-seam-apps-part-ii.html

Big File Upload Tutorial Using Seam

create your own stereotypes

2009-03-17T11:07:00.001+01:00

This link contains good info how to create your own stereotypes. http://www.ibm.com/developerworks/rational/library/05/0906_dusko/

JBoss Seam and Maven 2

2009-03-16T23:03:00.001+01:00

JBoss Seam and Maven 2

JBoss Seam, by default, is set up to compile, package, and deploy using Ant. Many developers, however, would like to use Maven 2 to build their application. In order to make the process of configuring Maven to correctly build a Seam project easier, Lunar Logic has created a Maven Archetype that will create an empty Seam project that compiles and packages using Maven 2.

The instructions for obtaining and using the archetype are located on the Lunar Logic Blog.

The instructions don't work quite as advertised, you can, however, download the archetype and install into the local maven2 repos by hand using 'mvn install'.

Also, I am working with the publisher to determine how to find a plugin that is used by the archetype called 'jboss-as-maven2-plugin'. Currently, you can create a new project, but it fails on any mvn command because it cannot locate this plugin.

Seam and Maven - archetype and SeamGen like application

You can also try Seam Maven integration by SoftEU. It provides few archetypes and Maven profiles for easier dependencies and SeamGen like application.

Script for creating a local maven 2 repo from a seam distribution

Two tools, one goal

2009-03-16T23:01:00.000+01:00

Two tools, one goal

Using a seam-gen project in JBoss Tools

The Seam distribution includes a tool named seam-gen to help you get started quickly using Seam. The tool collects information from you about your project and then uses that information to create a project structure. It can also generate a CRUD application by reverse engineering your database schema and generate various forms of stub code. In this entry, you'll learn how to get the generated project setup in Eclipse so that you can leverage the available tooling.

Two tools, one goal

There are actually two interfaces to seam-gen. The first is the commandline script named seam, which resides at the root of the Seam distribution. When we talk about seam-gen, we are usually referring to this script. There is also new project wizard in JBoss Tools (the open source project behind JBoss Developer Studio) that is a complement to this script. Both tools share the same FreeMarker templates inside the seam-gen directory of the Seam distribution to produce the Java code, Facelets views, and TestNG configuration. Aside from these common templates, the two tools work independently of one another in setting up a Seam project. The projects they generate differ in one fundamental way, though. The commandline tool produces projects that are built using Ant, while the JBoss Tools new project wizard creates projects that are build purely with Eclipse builders.

As you'd expect, when you create a project using the Eclipse plug-in, you can immediately start taking advantage of the tooling support for Seam in your project. However, like me, you may find it important to have a project that can be built outside of Eclipse using Ant. That means creating the project using the seam-gen commandline script. Don't fear that by creating the project outside of Eclipse, that the IDE is reduced to a syntax checker and Java compiler. The purpose of this article is to demonstrate how to fully activate the Seam tooling in Eclipse for projects created using the seam-gen commandline script, bringing you the best of both worlds. Plus, once the Seam tooling is activated, you can generate the CRUD application or stub code from either Eclipse or the commandline script.

Taylor - Modify Code

2009-03-16T22:31:00.001+01:00

Modify Code

Comments:

Your problem is actually easily solvable. RSA (Rational Software Architect) does that for you.

The basic issue is you view model as just a model. However, the tool you are using is viewing your code as the model. The term for it is code visualization.

You have the right idea in that model should be kept as abstract as possible. That's why RSA separated the concept of modelling from code visualization.

You just have to get something that would transform your model into other artifacts, which can be code, XML or maybe other models.

RSA provides you with the tools necessary to do that.

Posted by Archimedes Trajano on August 01, 2006 at 09:53 PM EDT #

I agree with the notion that many tools are on the code visualization side of things. And I will concede that RSA can handle this, but not without a lot of work and a lot of cash. I have used rational tools since the early Booch days through the present. You have to jump through a lot of hops, so I decided to build Taylor instead.

Anyway, my intend was to convey the idea and not so much slam the tools.

Thanks for your thoughts!

Posted by John Gilbert on August 03, 2006 at 05:56 PM EDT #

Core Seam

2009-03-14T23:21:00.000+01:00

Core Seam

documento PDF que explica detalladamente Seam por dentro

Arrogant Programmer

2009-03-14T23:08:00.001+01:00

Blog de un tipo que tiene comentarios interesantes sobre Seam

Controlling reverse engineering

2009-03-14T22:54:00.002+01:00

Controlling reverse engineering

When using the the ant task will read the database metadata and from that perform a reverse engineering of the database schema into a normal Hibernate Configuration. It is from this object e.g. >hbm2java<>

To govern this process Hibernate uses a reverse engineering strategy. A reverse engineering strategy is mainly called to provide more java like names for tables, column and foreignkeys into classes, properties and associations. It also used to provide mappings from SQL types to Hibernate types. The strategy can be customized by the user. The user can even provide its own custom reverse engineering strategy if the provided strategy is not enough, or simply just provide a small part of the strategy and delegate the rest to the default strategy.

5.1. Default reverse engineering strategy

The default strategy uses some rules for mapping JDBC artifact names to java artifact names. It also provide basic typemappings from JDBC types to Hibernate types. It is the default strategy that uses the packagename attribute to convert a table name to a fully qualified classname.

5.2. hibernate.reveng.xml file

To have fine control over the process a hibernate.reveng.xml file can be provided. In this file you can specify type mappings and table filtering. This file can be created by hand (its just basic XML) or you can use the Hibernate plugins which have a specialized editor.

Note: many databases is case-sensitive with their names and thus if you cannot make some table match and you are sure it is not excluded by a then check if the case matches; most databases stores table names in uppercase.

The following is an example of a reveng.xml. Following the example is more details about the format.

String	String	JSF Input Text
Text	String	Text Area - TinyMCE Editor
Date	Date	Seam Date Picker
Boolean	Boolean	JSF Check Box
Integer	Long	RichFaces Spinner
Decimal	Double	JSF Decimal
Currency	BigDecimal	JSF Currency
Percentage	Double	JSF Percentage
Byte[]	byte[]	Seam File Upload
Image	String	JSF Image
Link	String	JSF Link
Enumeration	your Enum	JSF SelectOne
Many to One Association	your Class	JSF SelectOne
Double	Double	deprecated - use Decimal, Currency, or Percentage
Long	Long	deprecated - use Integer

just my notes...

¿Un huevo de gallina es una célula?

beped: @create

hermes: Character encoding

Configuring a Seam EJB project for development with Maven and JBoss Tools

java parse fixed-length files (2)

Mission

Existing features

Java Schema Parser

Events for each line

Converter

Building java objects

Converting java objects into a file

Using xml as input

java parse fixed-length files

VTD-XML: The Future of XML Processing

XMLBeans Support for Built-In Schema Types

XMLBeans Tools

Open Source XML Parsers in Java

HERMES: Taylor identity para LDAP

ant tasks in maven

SeamTest and Maven

para probar Arquilian en hermes

TestNG

Arquilian

Para lo de unique numeroOrden-turno

hermes: validating properties referencing another object

hibernate: procesos batch

@PreUpdate @PrePersist

para los logs de los procesos

New (3.2.3) Hibernate identifier generators

Unified error page and exception handling

hermes: exceptions

Setting an isolation level

Transaction types

Hibernate exceptions

A history of exceptions

Have you ever found yourself frustrated with a ClassNotFoundException?

JavaBeans

Entity beans

Stateful session beans

Stateless session beans

El catalán es un dialecto del español

hsqldb

hibernate3:hbm2ddl

Palestina: región o estado

IBM WebSphere Application Server for Developers

proyecto base para hermes con seam 2.2.0.GA y JBoss AS 5.1

Using Maven, Eclipse and JBoss Tools

A Mavenized Seam Project Template

Manejar Proyectos J2EE

Hacer un merge entre dos ramas de SVN

deploying JEE5 apps on Websphere

Seam 2.2.0.GA JEE5 application running on WAS7

persistencia y transacciones

5.1. Hibernate Mapping Files

5.2. Injection Hibernate Session and SessionFactory

5.3. Access to org.hibernate.Session

5.4. Access to org.hibernate.Query

programmatic persistence properties in JPA

persistencia y transacciones

persistencia y transacciones

persistencia y transacciones

Test: trucos para acceder a recursos en los test

HIBERNATE: Para que solamente detecte las anotaciones

Hibernate - Cascade recommendations

Hibernate - Query Hints

teresa forcades - confabulación gripe A

Deploying custom resources

24.2.1. Using the Hibernate API

Display Error Messages on the Web Form

exception management in pages.xml

Annotate exceptios

SVN hooks for hudson builds

maven release version plugin

Taylor 1.3.0 - Writing Custom Generators

From Taylor

Contents

Plugin Basics

Create Plugin