Peco de Lucia

JMS - 1

2011-09-27T10:46:00.004+03:00

Messaging systems are
composed of messaging clients and some kind of messaging middleware server. The clients send messages to the messaging server, which then distributes those messages
to other clients. The client is a business application or component that is using the
messaging API (in our case, JMS).

Centralized Architectures

Enterprise messaging systems that use a centralized architecture rely on a message
server. A message server, also called a message router or broker, is responsible for delivering messages from one messaging client to other messaging clients.

Decentralized Architectures

All decentralized architectures currently use IP multicast at the network level. A messaging system based on multicasting has no centralized server.

Messaging Models

JMS supports two types of messaging models: point-to-point and publish-andsubscribe.
These messaging models are sometimes referred to as messaging domains.
Point-to-point messaging and publish-and-subscribe messaging are frequently shortened
to p2p and pub/sub, respectively.

In the simplest sense, publish-and-subscribe is intended for a one-to-many broadcast
of messages, while point-to-point is intended for one-to-one delivery of messages.

From a JMS perspective, messaging clients are called JMS clients, and the messaging system is called the JMS provider. A JMS application is a business system composed of many JMS clients and, generally, one JMS provider.

In addition, a JMS client that produces a message is called a message producer, while a
JMS client that receives a message is called a message consumer. A JMS client can be both a message producer and a message consumer. When we use the term consumer or producer, we mean a JMS client that consumes messages or produces messages, respectively.

Point-to-Point

The point-to-point messaging model allows JMS clients to send and receive messages
both synchronously and asynchronously via virtual channels known as queues. In the point-to-point model, message producers are called senders and message consumers
are called receivers.

One of the distinguishing characteristics of point-to-point messaging is that messages sent to a queue are received by one and only one receiver, even though there may be many receivers listening on a queue for the same message.

Point-to-point messaging supports asynchronous “fire and forget” messaging as well
as synchronous request/reply messaging. Point-to-point messaging tends to be more
coupled than the publish-and-subscribe model in that the sender generally knows how
the message is going to be used and who is going to receive it.

Publish-and-Subscribe
In the publish-and-subscribe model, messages are published to a virtual channel called
a topic. Message producers are called publishers, whereas message consumers are called
subscribers. Unlike the point-to-point model, messages published to a topic using the publish-and-subscribe model can be received by multiple subscribers. This technique is sometimes referred to as broadcasting a message. Every subscriber receives a copy of
each message. The publish-and-subscribe messaging model is by and large a push-based
model, where messages are automatically broadcast to consumers without them having
to request or poll the topic for new messages.

There are many different types of subscribers within the pub/sub messaging model.
Nondurable subscribers are temporary subscriptions that receive messages only when
they are actively listening on the topic. Durable subscribers, on the other hand, will
receive a copy of every message published, even if they are “offline” when the message
is published. There is also the notion of dynamic durable subscribers and administered durable subscribers.

JMS General API

Within the JMS general API, there are seven main JMS API interfaces related to sending
and receiving JMS messages:
• ConnectionFactory
• Destination
• Connection
• Session
• Message
• MessageProducer
• MessageConsumer

In JMS, the Session object holds the transactional unit of work for messaging, not the
Connection object. This is different from JDBC, where the Connection object holds the
transactional unit of work. This means that when using JMS, an application will typically have only a single Connection object but will have a pool of Session objects.

Point-to-Point API

The interfaces used for sending and
receiving messages from a queue are as follows:
• QueueConnectionFactory
• Queue
• QueueConnection
• QueueSession
• Message
• QueueSender
• QueueReceiver

Publish-and-Subscribe API

The interfaces used within the pub/sub
messaging model are as follows:
• TopicConnectionFactory
• Topic
• TopicConnection
• TopicSession
• Message
• TopicPublisher
• TopicSubscriber

SOA has given rise to a new breed of middleware known as an Enterprise Service
Bus, or ESB.

An InitialContext is the starting point for any JNDI lookup—it’s similar in concept to the root of a filesystem. The InitialContext provides a network connection to the directory service that acts as a root for accessing JMS administered objects. The properties used to create an InitialContext depend on which JMS directory service you are using. You could configure the initial context properties using the Properties Object directly in your source code, or preferably using an external jndi.properties file located in the classpath of the application.

The corresponding source code using the properties object would be as follows:

Properties env = new Properties();
env.put(Context.SECURITY_PRINCIPAL, "system");
env.put(Context.SECURITY_CREDENTIALS, "manager");
env.put(Context.INITIAL_CONTEXT_FACTORY,
"org.apache.activemq.jndi.ActiveMQInitialContextFactory");
env.put(Context.PROVIDER_URL, "tcp://localhost:61616");
InitialContext ctx = new InitialContext(env);

Once a JNDI InitialContext object is instantiated, it can be used to look up the Topic
ConnectionFactory in the messaging server’s naming service:
TopicConnectionFactory conFactory =
(TopicConnectionFactory)ctx.lookup(topicFactory);

The TopicConnectionFactory provides two overloaded versions of the createTopicCon
nection() method:

public TopicConnection createTopicConnection()
throws JMSException, JMSSecurityException;
public TopicConnection createTopicConnection(String username,
String password) throws JMSException, JMSSecurityException;

The TopicConnection is created by the TopicConnectionFactory:
// Look up a JMS connection factory and create the connection
TopicConnectionFactory conFactory =
(TopicConnectionFactory)ctx.lookup(topicFactory);
TopicConnection connection = conFactory.createTopicConnection();

The TopicConnection is an interface that extends javax.jms.Connection interface. It defines several generalpurpose methods used by clients of the TopicConnection. Among these methods are the start() , stop(), and close() methods:

public interface Connection {
public void start() throws JMSException;
public void stop() throws JMSException;
public void close() throws JMSException;
...
}

public interface TopicConnection extends Connection {
public TopicSession createTopicSession(boolean transacted,
int acknowledgeMode)
throws JMSException;

Closing a TopicConnection closes all the objects associated with the connection,
including the TopicSession, TopicPublisher, and TopicSubscriber.

After the TopicConnection is obtained, it’s used to create TopicSession objects:
// Create two JMS session objects

TopicSession pubSession = connection.createTopicSession(
false, Session.AUTO_ACKNOWLEDGE);
TopicSession subSession = connection.createTopicSession(
false, Session.AUTO_ACKNOWLEDGE);

The boolean parameter in the createTopicSession() method indicates whether the
Session object will be transacted.
The second parameter indicates the acknowledgment mode used by the JMS client. An
acknowledgment is a notification to the message server that the client has received the
message. In this case we chose AUTO_ACKNOWLEDGE, which means that the message is
automatically acknowledged after it is received by the client.

The TopicSession objects are used to create the TopicPublisher and TopicSubscriber.
The TopicPublisher and TopicSubscriber objects are created with a Topic identifier and
are dedicated to the TopicSession that created them; they operate under the control of
a specific TopicSession:
TopicPublisher publisher =
pubSession.createPublisher(chatTopic);
TopicSubscriber subscriber =
subSession.createSubscriber(chatTopic);

The TopicSession is also used to create the Message objects that are delivered to the
topic.
TextMessage message = pubSession.createTextMessage();

JNDI is used to locate a Topic object, which is an administered object like the Topic
ConnectionFactory:
InitialContext jndi = new InitialContext(env);
...
// Look up a JMS topic
Topic chatTopic = (Topic)jndi.lookup(topicName);

A Topic object is a handle or identifier for an actual topic, called a physical topic, on the messaging server. A physical topic is an electronic channel to which many clients can subscribe and publish.

The Topic object has one method, getName(), the name identifier for the physical topic it represents.

// Create a JMS publisher and subscriber
TopicSubscriber subscriber =
subSession.createSubscriber(chatTopic, null, true);

A TopicSubscriber receives messages from a specific topic. The Topic object argument
used in the createSubscriber() method identifies the topic from which the TopicSub
scriber will receive messages. The second argument contains the message selector used
to filter out only those messages we want to receive based on certain criteria. In this
case, we set this value to null, indicating that we want to receive all messages. The third argument contains a boolean value indicating whether or not we want to receive messages we publish ourselves. In this case, we are setting the value to true, indicating that, as a subscriber to the topic, we do not want to see messages we publish.

The pub/sub messaging model in JMS includes an in-process Java event model for
handling incoming messages. This is similar to the event-driven model used by Java-
Beans.‡ An object simply implements the listener interface, in this case the MessageLis
tener, and then is registered with the TopicSubscriber. A TopicSubscriber may have
only one MessageListener object. Here is the definition of the MessageListener

interface
used in JMS:
package javax.jms;
public interface MessageListener {
public void onMessage(Message message);
}

A message has three parts: a header, properties, and payload.

Message
This type has no payload. It is useful for simple event notification.

TextMessage
This type carries a java.lang.String as its payload. It is useful for exchanging
simple text messages and also for more complex character data, such as XML
documents.

ObjectMessage
This type carries a serializable Java object as its payload. It’s useful for exchanging
Java objects.

BytesMessage
This type carries an array of primitive bytes as its payload. It’s useful for exchanging
data in an application’s native format, which may not be compatible with other
existing Message types. It is also useful where JMS is used purely as a transport
between two systems, and the message payload is opaque to the JMS client.

StreamMessage
This type carries a stream of primitive Java types (int, double, char, etc.) as its
payload. It provides a set of convenience methods for mapping a formatted stream
of bytes to Java primitives. It’s an easy programming model when exchanging
primitive application data in a fixed order.

MapMessage
This type carries a set of name-value pairs as its payload. The payload is similar to
a java.util.Properties object, except the values must be Java primitives or their
wrappers. The MapMessage is useful for delivering keyed data.

JMS consumers
can choose to receive messages based on the values of certain headers and
properties, using a special filtering mechanism called message selectors.

Automatically assigned headers

There are two types of delivery modes in JMS: persistent and nonpersistent. A persistent message should be delivered once-and-only-once, which means that if the JMS provider fails, the message is not lost; it will be delivered after the server recovers. A nonpersistent message is delivered at-most-once, which means that it can be lost permanently if the JMS provider fails.

JMSDeliveryMode and the JMSPriority headers

int deliverymode = message.getJMSDeliveryMode();
if (deliverymode == javax.jms.DeliveryMode.PERSISTENT) {
...
} else { // equals DeliveryMode.NON_PERSISTENT
...
}

// Set the JMS delivery mode on the message producer
TopicPublisher topicPublisher = topicSession.createPublisher(topic);
topicPublisher.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

String messageid = message.getJMSMessageID();

long timestamp = message.getJMSTimestamp();

long timeToLive = message.getJMSExpiration();

TopicPublisher topicPublisher = topicSession.createPublisher(topic);
// Set time to live as 1 hour (1000 millis x 60 sec x 60 min)
topicPublisher.setTimeToLive(3600000);

boolean isRedelivered = message.getJMSRedelivered()

There are two categories of message priorities: levels 0–4 are gradations of normal priority, and levels 5–9 are gradations of expedited priority. The message servers may use a message’s priority to prioritize delivery of messages to consumers—messages with an expedited priority are delivered ahead of normal priority messages:
int priority = message.getJMSPriority();

The priority of messages can be declared by the JMS client using the setPriority()
method on the producer:

TopicPublisher topicPublisher = TopicSession.createPublisher(someTopic);
topicPublisher.setPriority(9);

Any direct programmatic invocation of the setJMSPriority() method will be ignored
when the message is sent.

Developer assigned headers

message.setJMSReplyTo(topic);
...
Topic topic = (Topic) message.getJMSReplyTo();

message.setJMSCorrelationID(identifier);
...
String correlationid = message.getJMSCorrelationID();

Properties

There are three basic categories of message properties: application-specific properties,JMS-defined properties, and provider-specific properties. Application properties are defined and applied to Message objects by the application developer; the JMS extension and provider-specific properties are additional headers that are, for the most part, automatically added by the JMS provider.

message.setStringProperty("username",username);
Property values can be any boolean, byte, short, int, long, float, double, or String.

Message
CF - connection - session - /_ MessageProducer ---|
\ MessageConsumer ---|
| |
| |
Destination --------------------------------------

Point-to-Point API
Message
QCF - Qconnection - Qsession - /_ QueueSender ---|
\ QueueReceiver--|
| |
| |
Queue -------------------------------------------

Publish-and-Subscribe API

Message
TCF - TConnection - TSession - /_ TopicPublisher--|
\ TopicSubscriber-|
| |
| |
Topic---------------------------------------------

public interface Message{
....
public short getShortProperty(String name)
throws JMSException, MessageFormatException;

public void setShortProperty(String name, short value)
throws JMSException, MessageNotWriteableException;

public Object getObjectProperty(String name)
throws JMSException, MessageFormatException;

public void setObjectProperty(String name, Object value)
throws JMSException, MessageNotWriteableException;

public void clearProperties()
throws JMSException;

public Enumeration getPropertyNames()
throws JMSException;

public boolean propertyExists(String name)
throws JMSException;
}

The properties can, however, be changed on that message by calling the method
clearProperties(), which removes all the properties from the message so that new ones
can be added.

Note that in the Message interface you will not find corresponding setJMSXERTY>() and getJMSX() methods defined; when used, they must be set in the
same manner as application-specified properties:

message.setStringProperty("JMSXGroupID", "ERF-001");
message.setIntProperty("JMSXGroupSeq", 3);

Provider-Specific Properties

Every JMS provider can define a set of proprietary properties that can be set by the
client or the provider automatically. Provider-specific properties must start with the
prefix JMS followed by the property name (JMS_). The purpose
of the provider-specific properties is to support proprietary vendor features.

Message Types

The six message interfaces are Message and its five subinterfaces:
TextMessage, StreamMessage, MapMessage, ObjectMessage, and BytesMessage.

-------------------
As shown below, the Message type can be created and
used as a JMS message with no payload:
// Create and deliver a Message
Message message = session.createMessage();
publisher.publish(message);
...
// Receive a message on the consumer
public void onMessage(Message message) {
// No payload, just process event notification
}

This type of message contains only JMS headers and properties and is used in event
notification.
-------------------
TextMessage textMessage = session.createTextMessage();
textMessage.setText("Hello!");
topicPublisher.publish(textMessage);
...

TextMessage textMessage = session.createTextMessage("Hello!");
queueSender.send(textMessage);
-------------------
// Order is a serializable object
Order order = new Order( );
...
ObjectMessage objectMessage = session.createObjectMessage();
objectMessage.setObject(order);
queueSender.send(objectMessage);
...
ObjectMessage objectMessage = session.createObjectMessage(order);
topicPublisher.publish(objectMessage);

-------------------
BytesMessage bytesMessage = session.createBytesMessage();
bytesMessage.writeChar('R');
bytesMessage.writeInt(10);
bytesMessage.writeUTF("OReilly");
queueSender.send(bytesMessage);

On the surface, the StreamMessage strongly resembles the BytesMessage, but they are
not the same. The StreamMessage keeps track of the order and types of primitives written.For example, an exception would be
thrown if you tried to read a long value as a short:

-------------------
StreamMessage streamMessage = session.createStreamMessage();
streamMessage.writeLong(2938302);
// The next line throws a JMSException
short value = streamMessage.readShort()
-------------------
MapMessage mapMessage = session.createMapMessage();
mapMessage.setInt("Age", 88);
mapMessage.setFloat("Weight", 234);
mapMessage.setString("Name", "Smith");
mapMessage.setObject("Height", new Double(150.32));
....
int age = mapMessage.getInt("Age");
float weight = mapMessage.getFloat("Weight");
String name = mapMessage.getString("Name");
Double height = (Double)mapMessage.getObject("Height");

To avoid reading nonexistent name-value pairs, the MapMessage provides an
itemExists() test method. In addition, the getMapNames() method lets a JMS client
enumerate the names and use them to obtain all the values in the message. For example:

public void onMessage(Message message) {
MapMessage mapMessage = (MapMessage)message;
Enumeration names = mapMessage.getMapNames();
while(names.hasMoreElements()){
String name = (String)names.nextElement();
Object value = mapMessage.getObject(name);
System.out.println("Name = "+name+", Value = "+value);
}
}

Read Only Messages

There are three acknowledgment modes that may be set by the JMS consumer when its session is created: AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE, and CLIENT_ACKNOWLEDGE. Here is how a pub/sub consumer sets one of the three acknowledgment modes:

TopicSession topic = topicConnection.createTopicSession(false, Session.CLIENT_ACKNOWLEDGE);

In CLIENT_ACKNOWLEDGE mode, the JMS consumer (client) explicitly acknowledges each message as it is received. The acknowledge() method on the Message interface is used
for this purpose. For example:

public void onMessage(Message message) {
message.acknowledge();
...
}

Chapter 4 - Point-to-Point Messaging

Chapter 5 - Publish-and-Subscribe Messaging

Each message is delivered to multiple message consumers, called subscribers.
There are many types of subscribers, including durable, nondurable, and dynamic.

Another major difference between the pub/sub and p2p models is that, with the pub/
sub model, message selectors are applied when the message is copied to each subscriber;
whereas with the p2p model, message selectors are applied after the message has been
added to the queue.

The important point here is that multiple consumers may consume the message.

JWS - reference

2011-09-26T13:46:00.004+03:00

Two ways to publish a web service using endpoint

Endpoint.publish("http://127.0.0.1:9876/ts", new TimeServerImpl());

Endpoint endpoint = Endpoint.create(new TimeServerImpl());
endpoint.publish(url);

2 ways to create a client:

QName qname = new QName("http://ts.ch01/", "TimeServerImplService");
Service service = Service.create(url, qname);
TimeServer eif = service.getPort(TimeServer.class);

or if you have already generated the artifacts with wsimport

TeamsService service = new TeamsService();
Teams port = service.getTeamsPort();

Document VS RPC
Under the rpc style, the messages are named but not explicitly typed; under the
document style, the messages are explicitly typed in an XSD document.

WRAPPED vs UNWRAPPED
The body of the unwrapped SOAP request envelope has two elements, named num1 and num2. These are numbers to be added. The SOAP body does not contain the name of the service operation that is to perform the addition and send the sum as a response. By contrast, the body of a wrapped SOAP request envelope has a single element named addNums, the name of the requested service operation, and two subelements, each holding a number to be added. The wrapped version makes the service operation explicit. The arguments for the operation are nested in an intuitive manner; that is, as subelements within the operation element addNums.

Guidelines for the wrapped document convention are straightforward. Here is a summary of the guidelines:

The SOAP envelope's body should have only one part, that is, it should contain a single XML element with however many XML subelements are required. For example, even if a service operation expects arguments and returns a value, the parameters and return value do not occur as standalone XML elements in the SOAP body but, rather, as XML subelements within the main element. Example 2-9 illustrates with the addNums element as the single XML element in the SOAP body and the pair num1 and num2 as XML subelements.

The relationship between the WSDL's XSD and the single XML element in the SOAP body is well defined. The document-style version of the TimeServer can be used to illustrate. In the XSD, there are four XSD complexType elements, each of which defines a data type. For example, there is a complexType with the name getTimeAsString and another with the name getTimeAsStringResponse. These definitions occur in roughly the bottom half of the XSD. In the top half are XML element definitions, each of which has a name and a type attribute. The complexTypes also have names, which are coordinated with the element names. For example, the complexType named getTimeAsString is matched with an element of the same name. Here is a segment of the XSD that shows the name coordination:

<xs:element name="getTimeAsString"
type="tns:getTimeAsString">
</xs:element>
<xs:element name="getTimeAsStringResponse"
type="tns:getTimeAsStringResponse">
</xs:element>
...
<xs:complexType name="getTimeAsString"></xs:complexType>
<xs:complexType name="getTimeAsStringResponse">
<xs:sequence>
<xs:element name="return"
type="xs:string" minOccurs="0">
</xs:element>
</xs:sequence>
</xs:complexType>

Further, each complexType is either empty (for instance, getTimeAsString) or contains an xs:sequence (for instance, getTimeAsStringResponse, which has an xs:sequence of one XML element). The xs:sequence contains typed arguments and typed returned values. The TimeServer example is quite simple in that the requests contain no arguments and the responses contain just one return value. Nonetheless, this segment of XSD shows the structure for the general case. For instance, if the getTimeAsStringResponse had several return values, then each would occur as an XML subelement within the xs:sequence. Finally, note that every XML element in this XSD segment (and, indeed, in the full XSD) is named and typed.

The XML elements in the XSD serve as the wrappers for the SOAP message body. For the ch01.ts.TimeServer, a sample wrapped document is:

<?xml version="1.0" ?>
<soapenv:Envelope
xmlns:soapenv="http://schemas.xmlsoap.or g/soap/envelope/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<soapenv:Body>
<ans:getTimeAsElapsedResponse xmlns:ans="http://ts.ch01/">
<return>1205030105192</return>
</ans:getTimeAsElapsedResponse>
</soapenv:Body>
</soapenv:Envelope>

This is the same kind of SOAP body generated for an rpc-style service, which is precisely the point. The difference, again, is that the wrapped document-style service, unlike its rpc-style counterpart, includes explicit type and format information in an XSD from the WSDL's types section.

The request wrapper has the same name as the service operation (for instance, addNums in Example 2-9), and the response wrapper should be the request wrapper's name with Response appended (for instance, addNumsResponse).

The WSDL portType section now has named operations (e.g., getTimeAsString) whose messages are typed. For instance, the input (request) message getTimeAsString has the type tns:getTimeAsString, which is defined as one of the four complexTypes in the WSDL's XSD. For the document-style version of the service, here is the portType segment:

<portType name="TimeServer">
<operation name="getTimeAsString">
<input message="tns:getTimeAsString"></input>
<output message="tns:getTimeAsStringResponse"></output>
</operation>
<operation name="getTimeAsElapsed">
<input message="tns:getTimeAsElapsed"></input>
<output message="tns:getTimeAsElapsedResponse"></output>
</operation>
</portType>

The wrapped document convention, despite its unofficial status, has become prevalent. JWS supports the convention. By default, a Java SOAP-based web service is wrapped doc/lit, that is, wrapped document style with literal encoding.

JAXB

JAX-B supports conversions between Java and XML types.

The @XmlType and @XmlRootElement annotations direct the marshaling of Skier objects, where marshaling is the process of encoding an in-memory object (for example, a Skier) as an XML document so that, for instance, the encoding can be sent across a network to be unmarshaled or decoded at the other end. In common usage, the distinction between marshal and unmarshal is very close and perhaps identical to the serialize/deserialize distinction. I use the distinctions interchangeably. JAX-B supports the marshaling of in-memory Java objects to XML documents and the unmarshaling of XML documents to in-memory Java objects.

The annotation @XmlType, applied in this example to the Person class, indicates that JAX-B should generate an XML Schema type from the Java type. The annotation @XmlRootElement, applied in this example to the Skier class, indicates that JAX-B should generate an XML document (outermost or root) element from the Java class. Accordingly, the resulting XML in this example is a document whose outermost element represents a skier; and the document has a nested element that represents a person.

Marshaling

JAXBContext ctx = JAXBContext.newInstance(Skier.class);
Marshaller m = ctx.createMarshaller();
m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

// Marshal a Skier object: 1st to stdout, 2nd to file
Skier skier = createSkier();
m.marshal(skier, System.out);

Unmarshaling

Unmarshaller u = ctx.createUnmarshaller();
Skier bd_clone = (Skier) u.unmarshal(new File(file_name));

@XmlRootElement(name = "getTimeAsElapsedResponse", namespace = "http://ts.ch02/")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "getTimeAsElapsedResponse", namespace = "http://ts.ch02/")
public class GetTimeAsElapsedResponse {
@XmlElement(name = "return", namespace = "")
private long _return;
public long get_return() { return this._return; }

public void set_return(long _return) { this._return = _return; }
}

The annotation in bold indicates that the field named _return will be marshaled and unmarshaled rather than a property defined with a get/set method pair that follows the usual JavaBean naming conventions.

Other annotation attributes can be set to override the default naming conventions. For example, if the annotation in the Skier class declaration is changed to:

@XmlRootElement(name = "NordicSkier")

then the resulting XML document begins:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<NordicSkier>

eclipse

2011-09-26T10:00:00.001+03:00

syso

ctrl +1 - quick fix

JWS - week 3

2011-09-20T10:47:00.003+03:00

So far web services have been deployed using either Endpoint, HttpsServer, or Tomcat.

A JAS is a: Web Container, Message-oriented middleware,
Enterprise Java Bean (EJB) container.

JMS topics implement the publisher/subscriber model of messaging, whereas JMS queues implement the point-to-point model.

The endpoint is different when deployed as an EJB
The endpoint URL for the EJB-based web service differs from WAR examples seen so far. For one thing, the name of the EAR file does not occur in the path as does the name of a WAR file. There are two pieces in the path section of the URL: the first is the SIB name with Service appended, giving FibEJBService in this example; the second is the SIB name, in this case FibEJB. The combination is shown in the URL below for the sample Perl client:

#!/usr/bin/perl -w
use SOAP::Lite;
use strict;
my $url = 'http://localhost:8081/FibEJBService/FibEJB?wsdl';
my $service = SOAP::Lite->service($url);
print $service->fib(7), "\n";

JWS - week 2

2011-09-12T10:13:00.015+03:00

wsimport vs wsgen

The wsimport tool generates JAX-WS portable artifacts used in JAX-WS clients and services. The tool reads a WSDL and generates all the required artifacts for web service development, deployment, and invocation.

In the working directory, invoke the wsimport utility, which likewise comes with core Java 6:

% wsimport -p teamsC -keep http://localhost:8888/teams?wsdl

This utility generates various classes in the subdirectory teamsC (the -p flag stands for package). These classes make it easier to write a client against the service.

% wsimport

displays a short report on how the utility can be used. The first example with wsimport produces client artifacts against the TimeServer service.

After the ch01.ts.TimeServerPublisher application has been started, the command:
% wsimport -keep -p client http://localhost:9876/ts?wsdl
generates two source and two compiled files in the subdirectory client.

wsimport -keep -p client ts.wsdl

The wsgen tool reads a service endpoint implementation class and generates all of the portable artifacts for a JAX-WS web service..

The wsgen utility also can be used to generate a WSDL document for a web service. For example, the command:

% wsgen -cp "." -wsdl ch01.ts.TimeServerImpl

The wsgen utility produces the classes required to build the WSDL, classes known as wsgen artifacts. The command:

% wsgen -keep -cp . ch01.ts.TimeServerImpl

MessageContext, which is normally accessed in handlers: the subtypes SOAPMessageContext and LogicalMessageMessageContext are the parameter types, for example, in the handleMessage callbacks of SOAP and logical handlers, respectively.

In a handler or SIB, Java provides access to HTTP messages in a MessageContext. In a Java-based client, Java likewise gives access to the HTTP level but in this case through the BindingProvider and the request/response contexts, which are exposed as BindingProvider properties. The code examples illustrate application-level as opposed to handler-level access to transport messages.

SOAP Attachments

There are basically three options for SOAP attachments: SwA (SOAP with Attachments), the original SOAP specification for attachments; DIME (Direct Internet Message Encapsulation), a lightweight but by now old-fashioned encoding scheme for attachments; and MTOM (Message Transmission Optimization Mechanism), which is based on XOP (XML-Binary Optimized Packaging). JWS has a DIME extension whose main purpose is to interoperate with Microsoft clients. Up until the release of Microsoft Office 2003, a web service client written in Visual Basic for Applications (VBA) could handle only DIME rather than MTOM attachments. The SwA approach has drawbacks. For one, it is hard to use SwA with a document-style service, which is now the norm. Further, frameworks such as DotNet do not support SwA. MTOM has the W3C stamp of approval and enjoys widespread support; hence, MTOM is the efficient, modern, interoperable way to transmit binary data in SOAP-based web services.

REST

As Web-based informational items, resources are pointless unless they have at least one representation. In the Web, representations are MIME-typed. The most common type of resource representation is probably still text/html, but nowadays resources tend to have multiple representations.

The RESTful approach keeps the complexity out of the transport level, as a resource representation is transferred to the client as the body of an HTTP response message. By contrast, a SOAP-based service inevitably complicates the transport level because a SOAP message is encapsulated as the body of a transport message; for instance, an HTTP or SMTP message. SOAP requires messages within messages, whereas REST does not.

The @WebService annotation signals that the messages exchanged between the service and its clients will be SOAP envelopes. The @WebServiceProvider signals that the exchanged messages will be XML documents of some type, a notion captured in the phrase raw XML

A service annotated with @WebServiceProvider implements the Provider interface, which requires that the invoke method:

public Source invoke(Source request)

be defined. This method expects a Source of bytes (for instance, the bytes in an XML document that represents the service request) and returns a Source of bytes (the bytes in the XML response).

A RESTful Provider implements the method:

public Source invoke(Source request)

and a Dispatch object, sometimes described as a dynamic service proxy, provides an implementation of this method on the client side. Recall that a Source is a source of an XML document suitable as input to a Transform, which then generates a Result that is typically an XML document as well. The Dispatch to Provider relationship supports a natural exchange of XML documents between client and service:

The client invokes the Dispatch method invoke, with an XML document as the Source argument. If the request does not require an XML document, then the Source argument can be null.

The service-side runtime dispatches the client request to the Provider method invoke whose Source argument corresponds to the client-side Source.

The service transforms the Source into some appropriate Result (for instance, a DOM tree), processes this Result in an application-appropriate way, and returns an XML source to the client. If no response is needed, null can be returned.

The Dispatch method invoke returns a Source, sent from the service, that the client then transforms into an appropriate Result and processes as needed.

The fact that the Provider method invoke and the Dispatch method invoke have the same signature underscores the natural fit between them.

WADL stands for Web Application Description Language

JAX-RS (Java API for XML-RESTful Web Services)

For now, JAX-WS and For now, JAX-WS and JAX-RS are separate frameworks. It would not be surprising if, in the future, the two frameworks merged are separate frameworks. It would not be surprising if, in the future, the two frameworks merged.

Java Web Services Security

HTTPS (HyperText Transport Protocol over Secure Socket Layer)

Java has various packages that support SSL/TLS in general and HTTPS in particular. JSSE (Java Secure Sockets Extension) has been part of core Java since JDK 1.4.

Peer authentication

Alice needs Bob to authenticate himself so that she is sure about who is on the receiving end before she sends the secret message. Bob, too, needs Alice to authenticate herself so that he knows that the secret message is from her rather than an impostor such as Eve. This step also is described as mutual authentication or mutual challenge.

Confidentiality

Once Alice and Bob have authenticated each other, Alice needs to encrypt the secret message in such a way that only Bob can decrypt it. Even if Eve intercepts the encrypted message, she should not be able to decrypt the message because doing so requires enormous computational power or incredibly good luck.

Integrity

The message that Alice sends should be identical to the one that Bob receives. If not, an error condition should be raised. The received message might differ from the sent one for various reasons; for instance, noise in the communications channel or deliberate tampering by Eve. Any difference between the sent and the received message should be detected.

Symmetric Encryption/Decryption
Modern approaches to encryption follow two different approaches, symmetric and asymmetric. Under either approach, the bits to be encrypted (plain bits) are one input to an encryption engine and an encryption key is the other input (see Figure 5-3). The encrypted bits are the cipher bits. If the input bits represent text, then they are the plaintext and the output bits are the ciphertext. The cipher bits are one input to the decryption engine, and a decryption key is the other input. The decryption produces the original plain bits. In the symmetric approach, the same key—called the secret key or the single key—is used to encrypt and decrypt (see Figure 5-4). The symmetric approach has the advantage of being relatively fast, but the disadvantage of what is known as the key distribution problem. How is the secret key itself to be distributed to the sender and the receiver?

Asymmetric Encryption/Decryption
In the asymmetric approach, the starting point is a key pair, which consists of a private key and a public key. As the names suggest, the private key should not be distributed but safeguarded by whoever generated the key pair. The public key can be distributed freely and publicly. If message bits are encrypted with the public key, they can be decrypted only with the private key, and vice-versa. Figure 5-5 illustrates. The asymmetric approach solves the key distribution problem, but asymmetric encryption and decryption are roughly a thousand times slower than their symmetric counterparts.

<Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"
maxThreads="150" scheme="https" secure="true"
clientAuth="false" sslProtocol="TLS" />

The clientAuth attribute is set to false, thereby indicating that Tomcat does not challenge the client. The default client behavior is to challenge the server.

JWS

2011-09-05T12:16:00.016+03:00

SOAP

REST

Simple Object Access Protocol (Service Oriented Architecture)
Representational State Transfer

A SOAP-based web service could be implemented as a single Java class but, following best practices, there should be an interface that declares the methods, which are the web service operations, and an implementation, which defines the methods declared in the interface. The interface is called the SEI: Service Endpoint Interface. The implementation is called the SIB: Service Implementation Bean

The other WSDL section of interest is the last, the service section, and in particular the service location, in this case the URL http://localhost:9876/ts. The URL is called the service endpoint and it informs clients about where the service can be accessed.

message exchange pattern (MEP)—request/response

WSDL - web service definition language

A SOAP-based web service should provide, as a WSDL document, a service contract for its potential clients. So far we have seen how a Perl, a Ruby, and a Java client can request the WSDL at runtime for use in the underlying SOAP libraries. Chapter 2 studies the WSDL more closely and illustrates how it may be used to generate client-side artifacts such as Java classes, which in turn ease the coding of web service clients. The Java clients in Chapter 2 will not be written from scratch, as is our first Java client. Instead such clients will be written with the considerable aid of the wsimport utility, as was the TeamClient shown earlier. Chapter 2 also introduces JAX-B (Java API for XML-Binding), a collection of Java packages that coordinate Java data types and XML data types. The wsgen utility generates JAX-B artifacts that play a key role in this coordination; hence, wsgen also will get a closer look.

XML-qualified name (a Java QName), which in turn consists of the service's local name (in this case, TimeServerImplService) and a namespace identifier (in this case, the URI http://ts.ch01/)

Building a client for the web service
wsimport -keep -p client http://localhost:9876/ts?wsdl
wsimport -keep -p client ts.wsdl

@WebMethod
@WebResult(partName = "time_response")
String getTimeAsString();

2.2 WSDL Structure
At a high level, a WSDL document is a contract between a service and its consumers. The contract provides such critical information as the service endpoint, the service operations, and the data types required for these operations. The service contract also indicates, in describing the messages exchanged in the service, the underlying service pattern, for instance, request/response or solicit/response. The outermost element (called the document or root element) in a WSDL is named definitions because the WSDL provides definitions grouped into the following sections:

The types section, which is optional, provides data type definitions under some data type system such as XML Schema. A particular document that defines data types is an XSD (XML Schema Definition). The types section holds, points to, or imports an XSD. If the types section is empty, as in the case of the TimeServer service, then the service uses only simple data types such as xsd:string and xsd:long.

Although the WSDL 2.0 specification allows for alternatives to XML Schema (see http://www.w3.org/TR/wsdl20-altschemalangs), XML Schema is the default and the dominant type system used in WSDLs. Accordingly, the following examples assume XML Schema unless otherwise noted.

The message section defines the messages that implement the service. Messages are constructed from data types either defined in the immediately preceding section or, if the types section is empty, available as defaults. Further, the order of the messages indicates the service pattern. Recall that, for messages, the directional properties in and out are from the service's perspective: an in message is to the service, whereas an out message is from the service. Accordingly, the message order in/out indicates the request/response pattern, whereas the message order out/in indicates the solicit/response pattern. For the TimeServer service, there are four messages: a request and a response for the two operations, getTimeAsString and getTimeAsElapsed. The in/out order in each pair indicates a request/response pattern for the web service operations.

The portType section presents the service as named operations, with each operation as one or more messages. Note that the operations are named after methods annotated as @WebMethods, a point to be discussed in detail shortly. A web service's portType is akin to a Java interface in presenting the service abstractly, that is, with no implementation details.

The binding section is where the WSDL definitions go from the abstract to the concrete. A WSDL binding is akin to a Java implementation of an interface (that is, a WSDL portType). Like a Java implementation class, a WSDL binding provides important concrete details about the service. The binding section is the most complicated one because it must specify these implementation details of a service defined abstractly in the portType section:

The transport protocol to be used in sending and receiving the underlying SOAP messages. Either HTTP or SMTP (Simple Mail Transport Protocol) may be used for what is called the application-layer protocol; that is, the protocol for transporting the SOAP messages that implement the service. HTTP is by far the more popular choice. The WSDL for the TimeServer service contains this segment:

transport="http://schemas.xmlsoap.org/soap/http">

The value of the transport attribute signals that the service's SOAP messages will be sent and received over HTTP, which is captured in the slogan SOAP over HTTP.

The style of the service, shown earlier as the value of the style attribute, takes either rpc or document as a value. The document style is the default, which explains why the SEI for the TimeServer service contains the annotation:

@SOAPBinding(style = Style.RPC)

This annotation forces the style attribute to have the value rpc in the Java-generated WSDL. The difference between the rpc and the document style will be clarified shortly.

The data format to be used in the SOAP messages. There are two choices, literal and encoded. These choices also will be clarified shortly.

The service section specifies one or more endpoints at which the service's functionality, the sum of its operations, is available. In technical terms, the service section lists one or more port elements, where a port consists of a portType (interface) together with a corresponding binding (implementation). The term port derives from distributed systems. An application hosted at a particular network address (for instance, 127.0.0.1) is available to clients, local or remote, through a specified port. For example, the TimeServer application is available to clients at port 9876.

By default, a Java SOAP-based web service is wrapped doc/lit, that is, wrapped document style with literal encoding.

The @XmlType and @XmlRootElement annotations direct the marshaling of Skier objects, where marshaling is the process of encoding an in-memory object (for example, a Skier) as an XML document so that, for instance, the encoding can be sent across a network to be unmarshaled or decoded at the other end. In common usage, the distinction between marshal and unmarshal is very close and perhaps identical to the serialize/deserialize distinction. I use the distinctions interchangeably. JAX-B supports the marshaling of in-memory Java objects to XML documents and the unmarshaling of XML documents to in-memory Java objects.

The annotation @XmlType, applied in this example to the Person class, indicates that JAX-B should generate an XML Schema type from the Java type. The annotation @XmlRootElement, applied in this example to the Skier class, indicates that JAX-B should generate an XML document (outermost or root) element from the Java class. Accordingly, the resulting XML in this example is a document whose outermost element represents a skier; and the document has a nested element that represents a person.

JAX-B JAVA To XML Binding

@XmlRootElement(name = "getTimeAsElapsedResponse", namespace = "http://ts.ch02/")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "getTimeAsElapsedResponse", namespace = "http://ts.ch02/")
public class GetTimeAsElapsedResponse {
@XmlElement(name = "return", namespace = "")
private long _return;
public long get_return() { return this._return; }

public void set_return(long _return) { this._return = _return; }
}

@XmlRootElement(name = "NordicSkier")

How the wsgen utility and the JAX-B packages interact in JWS now can be summarized. A Java web service in document rather than rpc style has a nonempty types section in its WSDL. This section defines, in the XML Schema language, the types required for the web service. The wsgen utility generates, from the SIB, Java classes that are counterparts of XSD types. These wsgen artifacts are available for the underlying JWS libraries, in particular for the JAX-B family of packages, to convert (marshal) instances of Java types (that is, Java in-memory objects) into XML instances of XML types (that is, into XML document instances that satisfy an XML Schema document). The inverse operation is used to convert (unmarshal) an XML document instance to an in-memory object, an object of a Java type or a comparable type in some other language. The wsgen utility thus produces the artifacts that support interoperability for a Java-based web service. The JAX-B libraries provide the under-the-hood support to convert between Java and XSD types. For the most part, the wsgen utility can be used without our bothering to inspect the artifacts that it produces. For the most part, JAX-B remains unseen infrastructure.

SOAP Message

Optional SOAP Header \_ SOAP Envelope
Required SOAP Body /

Optional SOAP attachments

SOAP handlers

Recall that a SOAP envelope has a required body, which may be empty, and an optional header. An intermediary should inspect and process only the elements in the SOAP header rather than anything in the SOAP body, which carries whatever cargo the sender intends for the ultimate receiver alone. The header, by contrast, is meant to carry whatever meta-information is appropriate for either the ultimate receiver or intermediaries.

JWS provides a handler framework that allows application code to inspect and manipulate outgoing and incoming SOAP messages. A handler can be injected into the framework in two steps:

One step is to create a handler class, which implements the Handler interface in the javax.xml.ws.handler package. JWS provides two Handler subinterfaces, LogicalHandler and SOAPHandler. As the names suggest, the LogicalHandler is protocol-neutral but the SOAPHandler is SOAP-specific. A LogicalHandler has access only to the message payload in the SOAP body, whereas a SOAPHandler has access to the entire SOAP message, including any optional headers and attachments. The class that implements either the LogicalHandler or the SOAPHandler interface needs to define three methods for either interface type, including handleMessage, which gives the programmer access to the underlying message. The other two shared methods are handleFault and close. The SOAPHandler interface requires the implementation to define a fourth method, getHeaders.

The other step is to place a handler within a handler chain. This is typically done through a configuration file, although handlers also can be managed through code.

JWS has two different ways to throw SOAP faults and the example illustrates both. The simplest way is to extend the Exception class (for example, with a class named FibException) and to throw the exception in a @WebMethod whenever appropriate. JWS then automatically maps the Java exception to a SOAP fault. The other way, which takes more work, is to throw a fault from a handler. In this case, a SOAPFaultException is created and then thrown.

The top-to-bottom sequence of the handlers in the configuration file determines the order in which handler methods of one type (e.g., SOAPHandler) execute. The runtime ordering may differ from the order given in the configuration file. Here is the reason:

For an outbound message (for instance, a client request under the request/response MEP), the handleMessage method or handleFault method in a LogicalHandler code execute before their counterparts in a SOAPHandler.

For an inbound message, the handleMessage method or handleFault method in a SOAPHandler code execute before their counterparts in a LogicalHandler.

JPA2

2011-09-01T16:37:00.006+03:00

82

Identifier Generation

@GeneratedValue

AUTO, TABLE, SEQUENCE, or IDENTITY

@Entity
public class Employee {
@Id @GeneratedValue(strategy=GenerationType.AUTO)
private int id;
// ...
}

Id Generation Using a Table

@Id @GeneratedValue(strategy=GenerationType.TABLE)
private int id;

@TableGenerator(name="Emp_Gen")
@Id @GeneratedValue(generator="Emp_Gen")
private int id;

@TableGenerator(name="Emp_Gen",
table="ID_GEN",
pkColumnName="GEN_NAME",
valueColumnName="GEN_VAL")

@TableGenerator(name="Address_Gen",
table="ID_GEN",
pkColumnName="GEN_NAME",
valueColumnName="GEN_VAL",
pkColumnValue="Addr_Gen",
initialValue=10000,
allocationSize=100)
@Id @GeneratedValue(generator="Address_Gen")
private int id;

Id Generation Using a Database Sequence

@Id @GeneratedValue(strategy=GenerationType.SEQUENCE)
private int id;

@SequenceGenerator(name="Emp_Gen", sequenceName="Emp_Seq")
@Id @GeneratedValue(generator="Emp_Gen")
private int getId;

CREATE SEQUENCE Emp_Seq
MINVALUE 1
START WITH 1
INCREMENT BY 50

Id Generation Using Database Identity

@Id @GeneratedValue(strategy=GenerationType.IDENTITY)
private int id;

There is no generator annotation for IDENTITY because it must be defined as part of the database schema definition for the primary key column of the entity. Because each entity primary key column defines its own identity characteristic, IDENTITY generation cannot be shared across multiple entity types.
Another difference, hinted at earlier, between using IDENTITY and other id generation strategies is that the identifier will not be accessible until after the insert has occurred

Relationships

Relantionship Concepts:

Roles

Directionality

Cardinality

Ordinality

Single-Valued Associations/
An association from an entity instance to another entity instance (where the cardinality of the target is “one”) is called a single-valued association. The many-to-one and one-to-one relationship mappings fall into this category because the source entity refers to at most one target entity.

Many-to-One Mappings
@Entity
public class Employee {
// ...
@ManyToOne
private Department department;
// ...
}

A many-to-one mapping is defined by annotating the attribute in the source entity (the attribute that refers to the target entity) with the @ManyToOne annotation

Using Join Columns
In almost every relationship, independent of source and target sides, one of the two sides will have the join column in its table. That side is called the owning side or the owner of the relationship. The side that does not have the join column is called the non-owning or inverse side.

@Entity
public class Employee {
@Id private int id;
@ManyToOne
@JoinColumn(name="DEPT_ID")
private Department department;
// ...
}

One-to-One Mappings

@Entity
public class Employee {
@Id private int id;
private String name;
@OneToOne
@JoinColumn(name="PSPACE_ID")
private ParkingSpace parkingSpace;
// ...
}

Bidirectional One-to-One Mappings

@Entity
public class ParkingSpace {
@Id private int id;
private int lot;
private String location;
@OneToOne(mappedBy="parkingSpace")
private Employee employee;
// ...
}

The value of mappedBy is the name of
the attribute in the owning entity that points back to the inverse entity.
The two rules, then, for bidirectional one-to-one associations are the following:
• The @JoinColumn annotation goes on the mapping of the entity that is mapped to
the table containing the join column, or the owner of the relationship. This might
be on either side of the association.
• The mappedBy element should be specified in the @OneToOne annotation in the
entity that does not define a join column, or the inverse side of the relationship.

95

JPA2

2011-07-25T16:49:00.005+03:00

69
Persistence annotations can be applied at three different levels: class, method, and field

The mapping annotations can be categorized as being in one of two categories: logical
annotations and physical annotations

ACCESSING ENTITY STATE
If we annotate fields, the provider will get and set the fields of the entity using reflection.

If the annotations are set on the getter methods of properties, those getter and setter methods will be invoked by the provider to access and set the state.

@Entity
public class Employee {
@Id private int id;

Mixed access
@Entity
@Access(AccessType.FIELD)
public class Employee {
public static final String LOCAL_AREA_CODE = "613";
@Id private int id;
@Transient private String phoneNum;
…
public int getId() { return id; }
public void setId(int id) { this.id = id; }

Mapping To A Table

Listing 4-4. Overriding the Default Table Name
@Entity
@Table(name="EMP")
public class Employee { ... }

Listing 4-5. Setting a Schema
@Entity
@Table(name="EMP", schema="HR")
public class Employee { ... }

Listing 4-6. Setting a Catalog
@Entity
@Table(name="EMP", catalog="HR")
public class Employee { ... }

Mapping Simple Types
If the type from the JDBC layer cannot be converted to the Java type of the
field or property, an exception will normally be thrown, although it is not guaranteed.

An optional @Basic annotation can be placed on a field or property to explicitly mark it as being persistent. This annotation is mostly for documentation purposes and is not required for the field or property to be persistent. Because of the annotation, we call mappings of simple types basic mappings. Now that we have seen how we can persist either fields or properties and how they are virtually equivalent in terms of persistence, we will just call them attributes. An attribute is a field or property of a class, and we will use the term attribute from now on to avoid having to continually refer to fields or properties in specific terms.

Column Mappings

Listing 4-7. Mapping Attributes to Columns
@Entity
public class Employee {
@Id
@Column(name="EMP_ID")
private int id;
private String name;
@Column(name="SAL")
private long salary;
@Column(name="COMM")
private String comments;
// ...
}

Lazy Fetching

Listing 4-8. Lazy Field Loading
@Entity
public class Employee {
// ...
@Basic(fetch=FetchType.LAZY)
@Column(name="COMM")
private String comments;
// ...
}

Second, on the surface it might appear that this is a good idea for certain attributes of an entity, but in practice it is almost never a good idea to lazily fetch simple types.

Large Objects

Listing 4-9. Mapping a BLOB Column
@Entity
public class Employee {
@Id
private int id;
@Basic(fetch=FetchType.LAZY)
@Lob @Column(name="PIC")
private byte[] picture;
// ...
}

Enumerated Types

@Entity
public class Employee {
@Id private int id;
private EmployeeType type;
// ...
}

Listing 4-11. Mapping an Enumerated Type Using Strings
@Entity
public class Employee {
@Id
private int id;
@Enumerated(EnumType.STRING)
private EmployeeType type;
// ...
}

Temporal Types

Listing 4-12. Mapping Temporal Types
@Entity
public class Employee {
@Id
private int id;
@Temporal(TemporalType.DATE)
private Calendar dob;
@Temporal(TemporalType.DATE)
@Column(name="S_DATE")
private Date startDate;
// ...
}

Transient State
Attributes that are part of a persistent entity but not intended to be persistent can either be modified with the transient modifier in Java or be annotated with the @Transient annotation.

81

JPA2 - 04 iulie

2011-07-04T10:47:00.003+03:00

Dependency lookup

A reference is declared using one of the resource reference annotations: @Resource, @EJB, @PersistenceContext, or @PersistenceUnit.

@Stateless
public class EmployeeServiceBean implements EmployeeService {
@PersistenceContext(unitName="EmployeeService")
EntityManager em;
// ...
}

@Stateful
public class EmployeeServiceBean implements EmployeeService {
@PersistenceUnit(unitName="EmployeeService")
private EntityManagerFactory emf;
private EntityManager em;
@PostConstruct
public void init() {
em = emf.createEntityManager();
}
// ...
}

@Stateless
public class DeptServiceBean implements DeptService {
@EJB(beanName="AuditServiceBean")
AuditService audit;
// ...
}

Transactions
@Stateless
@TransactionManagement(TransactionManagementType.BEAN)
public class ProjectServiceBean implements ProjectService {
// methods in this class manually control transaction demarcation
}

@Stateful
public class ShoppingCartBean implements ShoppingCart {
@TransactionAttribute(TransactionAttributeType.SUPPORTS)
public void addItem(String item, Integer quantity) {
verifyItem(item, quantity);
// ...
}
// ...
}

CMT or BMT

JPA2 - 30 iunie

2011-06-30T11:00:00.008+03:00

em.find(Employee.class,14)
em.remove(emp);
em.getTransaction().begin();
em.getTransaction().commit();
em.close();
emf.close();

Query - either Query or TypedQuery

1. static query - named query
2. dynamic query

TypedQuery query = em.createQuery("SELECT e from EMPLOYEE e");
List emps = em.getResultList();

<persistence-unit name="EmployeeService"
transaction-type="RESOURCE_LOCAL">
RESOURCE_LOCAL means that we are using resource-level EntityTransaction
isntead of JTA.

---------------
calculat ca imi ia 22 de zile sa citesc cartea (hai sa vedem daca reusim in 5)
---------------

Session beans - encapsulate business services
have a business interface
a client gets a session bean and starts a session with that bean

3 types - stateless, stateful and singleton
business operations on a stateful session bean can maintain state on the bean between calls. This is not true for a stateless session bean.
singleton - just one

@Stateless annotation

To emphasize that an interface is a local business interface @Local annotation
can be put on the interface.

Local business interface means that it is accessible to clients only within the same application server.

You can also define it with no interface. In this case the local business interface will be considered the public methods from that class.

For
stateless session beans, there are two lifecycle callbacks: PostConstruct and PreDestroy.

The server will invoke the PostConstruct callback as soon as it has completed initializing all the container services for the bean. In effect, this replaces the constructor as the location for initialization logic because it is only here that container services are guaranteed to be available.

@Remote
public interface HelloServiceRemote {
public String sayHello(String name);
}

@Stateful
public class ShoppingCartBean implements ShoppingCart {

@Remove
public void checkout(int paymentId) {
// store items to database
// ...
}
}

Passivation is the process by which
the server serializes the bean instance so that it can either be stored offline to free up resources or
replicated to another server in a cluster. Activation is the process of deserializing a passivated session
bean instance and making it active in the server once again.

@PrePassivate
public void passivate() { releaseConnection(); }
@PostActivate
public void activate() { acquireConnection(); }

Unlike other session beans, the singleton can be created eagerly during application initialization and exist until the application shuts down.

@Singleton
public class HitCounter {
int count;
public void increment() { ++count; }
public void getCount() { return count; }
public void reset() { count = 0; }
}

The container determines the point when the singleton instance gets created unless the bean includes the @Startup annotation to force eager initialization when the application starts.

When multiple singleton session beans depend on one another, the container needs to be informed of the order in which they should be instantiated. This is accomplished via the @DependsOn annotation on the bean class, which lists the names of other singleton session beans that must be created first.

@Singleton
public class HitCounter {
int count;
public void increment() { ++count; }
@Lock(LockType.READ)
public void getCount() { return count; }
public void reset() { count = 0; }
}

For those who wish to have fine-grained control over concurrency, the singleton session bean can be configured to use bean-managed concurrency via the
@ConcurrencyManagement(ConcurrencyManagementType.BEAN) annotation on the bean class.

@MessageDriven(
activationConfig = {
@ActivationConfigProperty(propertyName="destinationType",
propertyValue="javax.jms.Queue"),
@ActivationConfigProperty(propertyName="messageSelector",
propertyValue="RECIPIENT='ReportProcessor'")
})
public class ReportProcessorBean implements javax.jms.MessageListener {
public void onMessage(javax.jms.Message message) {
// ...

JPA2

2011-06-29T08:54:00.004+03:00

Objects that leave the persistence layer are called detached objects

The set of managed entity instances within an entity manager at any
given time is called its persistence context.

There is an one-to-one correspondence between an EntityManagerFactory and a persistence unit.

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

correspondence timeunit ?

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

EntityManagerFactory emf =
Persistence.createEntityManagerFactory("EmployeeService");

1 to 1 EntityManagerFactory and persistence unit

5th of april

2011-04-05T10:05:00.004+03:00

morning - figure out a plan for doing something, think of an activity for after
noon - take the towel (do some cleaning - take trash,etc)
after work - continue cleaning,clean the computer, change, if enough time do some shopping, think of an activity

acting, cantat in pasaj, cantat in dal, unghii

JSF2 complete reference - again 6 - march 31

2011-03-31T18:47:00.002+03:00

312 (343)

read about a simple input component, the fact
that u have to declare in a taglib.xml and also
have the java class that defines the component (u could also
have a separate renderer).

The java class must have an annotation @FacesComponent(value = "nameOfTheComponent")
or you have to declare in faces-config.xml.

JSF2 complete reference - again 6 - march 24

2011-03-23T17:56:00.001+02:00

JSF2 complete reference - again 6 - march 23

2011-03-22T18:25:00.001+02:00

Advanced Composite Component Development

JSF2 complete reference - again 5 - march21

2011-03-21T10:06:00.002+02:00

The result will be that the same Facelet page will
appear differently when viewed in a desktop Web browser and on the Apple mobile device,
as shown in Figure 11-8.
To make this possible, we rely on two basic concepts: a JSF PhaseListener and class
decoration. This example will provide a foundation for a more complete customization,
as well as showing how to automatically deliver a client device–specific CSS style sheet
to the user agent, and allow you to tailor how individual markup elements are displayed.

<lifecycle>
<phase-listener>com.jsfcompref.components.renderer.applemobile.
RenderKitSelectorPhaseListener</phase-listener>
</lifecycle>

The subtlety comes from how we must take
action in the afterPhase( ) method of restore view because this is the earliest time in the
lifecycle when context.getViewRoot( ) returns non-null.

JSF2 complete reference - again 4 - march18

2011-03-18T10:19:00.004+02:00

<?xml version='1.0' encoding='UTF-8'?>
<facelet-taglib xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-facelettaglibrary_2_0.xsd"
version="2.0">
<namespace>http://jsfcompref.com/example</namespace>
<tag>
<tag-name>helloworld</tag-name>
<component><component-type>HtmlHelloWorld</component-type></component>
</tag>
</facelet-taglib>

Now that we’ve created a simple, but fully functional component, we can begin adding
attributes to the component. Because HtmlHelloWorld extends from UIComponentBase,
UIComponent properties from the superclass such as id, binding, rendered are already
available for use in the Facelet page.

Prior to JSF 2.0, component state was typically stored in instance
variables on the UIComponent subclass. For example, the UIInput component has a valid
property, which indicates whether this component is valid or not. This value would be stored
in a simple boolean instance variable, accessed via a JavaBeans getter and setter and handled
explicitly in the saveState( ) and restoreState( ) methods. JSF 2.0 introduces the StateHelper
interface to make this sort of activity easier and less error prone.

JSF2 complete reference - again 3

2011-03-16T17:36:00.001+02:00

TIP OF THE DAY: make the order button a composite component

Finally, notice the @FacesComponent annotation. This annotation is an alternative for
the following XML in the faces-config.xml file:
<component>
<component-type>HtmlHelloWorld</component-type>
<component-class>
com.jsfcompref.components.component.HtmlHelloWorld
</component-class>
</component>

310

JSF2 complete reference - again 2

2011-03-15T10:06:00.004+02:00

For example <h:outputLabel
for="#{cc.clientId}:userid" value="Userid:" />
causes the label to have the correct absolute
client ID to the actual userid text field.

<h:inputSecret required="true"
validatorMessage="#{cc.attrs.passwordValidatorMessage}"
requiredMessage="Password is required" id="password" />

JSF2 complete reference - again 1

2011-03-14T14:08:00.002+02:00

UI component is something that has
appearance, state, and behavior.

xmlns:vt="http://java.sun.com/jsf/composite/trainer"

vt:loginPanel

that means the file is src/main/webapp/resources/trainer/loginPanel.xhtml.

301 .....1:40, 2:46 at least

march 03 11

2011-03-03T22:21:00.001+02:00

jimi
von doran
left V
picking
pick by ear
read
band

6

2011-01-12T20:22:00.001+02:00

plan

fretboard mastery
repertoire
technique - left
- right
transcribing
reading

1

2011-01-04T22:18:00.002+02:00

technique
1 hour
4 notes pentatonic, accenting up
C 5th pattern 2nd oct, 2,3,4,5 - even accenting up

GP - 1st month

2010-12-20T21:57:00.002+02:00

fretboard mastery
working on metal rhythm
minor, major, dorian, mixolydian
solo for sweet home alabama

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

applying minor, major, dorian, mixolydian
learn new chord
try to do a tune with walking bass, learn the charlestone rhythm
improve picking speed

16 dec 2010

2010-12-16T11:33:00.002+02:00

1. Save cache server
2. Add dynamic subtab(DAS) and ask about making a tab disabled
3. Work on a datatable with change row order
4. Make buttons next, previous work.

Bindu' list

2010-11-30T16:40:00.001+02:00

JPA

Entity instances are in one of four states: new, managed, detached, or removed.

tuesday, 9th of november

2010-11-09T09:54:00.005+02:00

Bindu's list

1.Training
===========================

15 nov - 20 nov
---------------------------
add, edit, delete, list app
jsf 2, jpa, spring, oracle, junit

and

V12 Coding Guidelines
Package Structure
Data Access Layer
Service Layer

23 nov - 28 nov
------------------------
only UI stuff

2. MTT
========================

15 nov - 20 nov
------------------------
general flow and UI schemas,
write final version for document

23 nov - 28 nov
------------------------
Implement Add, Edit , Delete for a simple object

Friday, 05 nov

2010-11-05T20:19:00.006+02:00

chapter 9 - the virtual trainer application
-------------------------------------------
the @ManagedBean annotation may never appear on an abstract
class.

Michael Jouravlev, in his influential August 2004 article on theserverside.com, describes the
POST REDIRECT GET (PRG) pattern as follows:
Never show pages in response to POST
Always load pages using GET
Navigate from POST to GET using REDIRECT

Composite Components

com.jsfcompref.trainer.Messages
bundle

Thursday, 04 nov

2010-11-04T15:30:00.005+02:00

chapter 9 - The JSF Event Model
---------------------------
There are two broad categories of events in JSF, application events and lifecycle events.

James Blunt - Stay the night

if you want to address like this something
#{something} u can put it in the requestMap

requestMap.put("something", message);

ActionSource2 components -> action event -> action listener
ValueHolder components -> value change event -> value change listener

EventObject --> FacesEvent --> ActionEvent or ValueChangeEvent

There are also: phase events and phase listeners

system events (validation about to occur on this component or this component
is about to be rendered)

Application Events - action event, value change
Lifecycle events - phase events, system events

• The Lifecycle instance may have zero or more PhaseListeners attached to it.
• A UIViewRoot instance may have from zero to two PhaseListeners attached to it.
• Every UIComponent instance may have zero or more SystemEventListeners
attached to it.
• Every instance of a component in the javax.faces.component.html package may
have zero or more ClientBehaviors attached to it, and to each of those may be
attached zero or more BehaviorListener interfaces. (The behavior system will be
explained completely in Chapter 12.)
• Every UIInput instance may have zero or more ValueChangeListeners attached to it.
• Every UICommand may have zero or more ActionListeners attached to it.

ActionEvent - At the completion of the Invoke Application
phase unless the immediate flag is true;
then it is processed at the end of the Apply
Request Value phase.

ValueChangeEvent - At the completion of the Process
Validations phase unless the immediate
flag is true; then it is processed at the end
of the Apply Request Value phase.

Pressing A Button
To record the button click event, the Faces lifecycle instantiates an ActionEvent
object and passes it as an argument to the UICommand’s queueEvent( ) method.

For action events, it is also possible to just
write either an action method or an action listener method.

The key point to remember with an action method is
that it relies on the built-in default ActionListener to invoke it and then pass this value to the NavigationHandler in order to determine if a navigation is needed.

public void addConfirmedUserListenerAction(ActionEvent ae) {
// This method would call a database or other service
// and add the confirmed user information.
System.out.println("Adding new user…");
}

For example, you may want to provide a Cancel button that calls a
method before validating the field values. To short-circuit the processing of the action event, one simply sets the UI component’s immediate attribute to true.

Changing The Value In An Input And Submitting
unlike the action event in which the event is processed during the
Invoke Application phase, value change events are processed in the Process Validations phase.

Writing Custom Action and Value Change Listeners

type="com.jsfcompref.MyActionListener">

type="com.jsfcompref.MyValueChangeListener"/>

Avoid having both value-bound and component-bound properties in a single
managed bean class.

By placing immediate="true" on every component that should participate in the partial validation, and by not having this attribute on the rest of the components, validation is bypassed for those components that do not have the attribute.

@ListenerFor(systemEventClass=PreValidateEvent.class)
public class MyInput extends UIInput {
...
public void processEvent(ComponentSystemEvent event)
throws AbortProcessingException {
super.processEvent(event);
// do any pre-validate stuff here
}
}

@ListenersFor({
@ListenerFor(systemEventClass=PostAddToViewEvent.class)
@ListenerFor(systemEventClass=PostConstructViewMapEvent.class)
})
public class MyInput extends UIInput {
...

listener="an EL expression that points to a method that
returns void and takes a ComponentSystemEvent" />

wednesday, 03 nov

2010-11-03T13:54:00.004+02:00

chapter 7 - the user interface component model

ActionSource2

ValueHolder

PartialStateHolder

NamingContainer

you have a component, a renderer and a tag handler

chapter 8 - converting and validating data
------------------------------------------

first conversion then validation

convertor

public Object getAsObject(FacesContext context,
UIComponent component,
String value)
public String getAsString(FacesContext context,
UIComponent component,
Object value)

u can have only one convertor max

if it's immediate - then the validation is done in apply request values phase

u have implicit conversion(when u have value binding) and explicit
conversion (when u specify a convertor by class of by convertor id)

u can also add programmatically a convertor

// Create the Converters, one by type, the other by Class.
intConverter =
context.getApplication( ).createConverter("javax.faces.Integer");
floatConverter =
context.getApplication( ).createConverter(Float.class);
// Install the converters.
component1.setConverter(intConverter);
component2.setConverter(floatConverter);

if you register a convertor by class
then it can be used for implicit conversion

validator interface

public void validate(FacesContext context,
UIComponent component,
Object value)

before validating the component is marked as invalid

validators are registered only by validator-id

u can make jsf not validate empty fields

javax.faces.VALIDATE_EMPTY_FIELDS

false

As an alternative to the required attribute, it is possible to nest an
element within any input component to achieve the same effect.

It’s very important to note that, when nesting, any validators, or settings on validators,
that happen inside of the nesting take precedence over whatever validators or settings are
specified on the wrapping validator(s).

standard validators have a property disabled which can an el expression as value

so u can add a validator by
validator attribute
special tag (standard or by f:validator and providing validator id)
programmatically

The markup tags all result in a call to addValidator( ) on the underlying
component instance, and the required attribute results in a call to setRequired(true) on the
component.

Bean Validation

@ManagedBean
@SessionScoped
public class UserBean {
protected String sex;
@NotEmpty(message="You must supply an email address")
@Email
protected String email;

!!! The FacesContext is an object per request

FacesMessage - severity, summary and detail

FacesContext contains two lists of messages
- associated with a component
- not associated with a component

different variants of the getMessages( ) method on
FacesContext. The variant that takes no arguments returns an Iterator of all messages, associated with a component or not. The variant that takes a clientId gets only messages associated with the component of that clientId, or, if the clientId is null, gets only messages that are not associated with a specific clientId.

The FacesContext is the place where you obtain the UIViewRoot for the current view

There are exactly three times in the request processing lifecycle when the standard
components will create a FacesMessage instance and add it to the FacesContext: when
conversion fails, when validation fails, or when the converted and validated data cannot be pushed to the model during the Update Model Values phase.

com.jsfcompref.Messages

You can also override the message using the requiredMessage, converterMessage, or
validatorMessage property of UIInput. This is exposed as a tag attribute on all of the tags that expose UIInput components to the page author.

@Email(message="Silly user, your email is invalid")
private String email;

@Email(domain=".org")
private String email;
The entry in the ValidationMessages_en.properties file is shown next:
validator.email=Invalid email address. Must end in {domain}.

chapter 9 - The JSF Event Model
---------------------------
There are two broad categories of events in JSF, application events and lifecycle events.

James Blunt - Stay the night

Tuesday, 02 nov

2010-11-02T20:24:00.007+02:00

chapter 6 - the navigation model
--------------------------------
action attribute
h:commandButton
h:commandLink

outcome attribute
h:button
h:link

in MVC the Faces Servlet acts as the controller

an event triggered by a component which implements ActionSource interface
-> navigation event -> NavigationHandler

component that implements ActionSource2 interface means that this
component is the source of an ActionEvent

apply request values - triggering an ActionEvent
invoke application - the default ActionListener.processAction is called
which calls the action method and generates an outcome
after that NavigationHandler.handleNavigation is called if outcome not null

which does FacesContext.setViewRoot(new UIViewRoot())

if outcome null or not a valid outcome - user remains on the same page

this usually results in RequestDispatcher.forward() being called

<if>#{model.booleanValue}</if>

redirect means that you generate another request

<navigation-case>
<from-action>#{Login.loginAction}</from-action>
<from-outcome>success</from-outcome>
<to-view-id>/success.xhtml</to-view-id>
<redirect/>
</navigation-case>

h:button and h:link do GET
h:commandButton and h:commandLink do POST

h:commandButton value="HTTP POST with Redirect" action="page02?facesredirect=true"

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

<f:metadata>
<f:viewParam name="fname" value="#{userBean.firstName}" />
<f:viewParam name="lname" value="#{userBean.lastName}" />
<f:viewParam name="sex" value="#{userBean.sex}" />
<f:viewParam name="dob" value="#{userBean.dob}">
<f:convertDateTime pattern="MM-dd-yy" />
</f:viewParam>
<f:viewParam name="email" value="#{userBean.email}" />
<f:viewParam name="sLevel" value="#{userBean.serviceLevel}" />
</f:metadata>

<navigation-rule>
<from-view-id>whatever the from view id is</from-view-id>
<navigation-case>
<from-outcome>whatever the outcome value is</from-outcome>
<to-view-id>whatever the to view id is</to-view-id>
<redirect>
...the view-param elements are optional
<view-param>
<name>any string is fine here</name>
<value>any string or value expression is fine here</value>
</view-param>
...additional view-param elements may be defined
</redirect>
</navigation-case>
</navigation-rule>

<error-page>
<exception-type>javax.faces.application.ViewExpiredException
</exception-type>
<location>/faces/sessionExpired.xhtml</location>
</error-page>
<error-page>
<exception-type>com.jsfcompref.BadUserException
</exception-type>
<location>/faces/badUser.xhtml</location>
</error-page>

The UI component tree is fully managed by the ViewHandler between requests. However, it is
the role of the StateManager to preserve the UI component tree in between subsequent
requests. It saves the complete status of the component tree using one of several different statesaving
methods specified as a context parameter (javax.faces.STATE_SAVING_METHOD) in
the Web application’s web.xml file. The different state-saving parameters are server and client.

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

chapter 7 - the user interface component model

ActionSource2

ValueHolder

PartialStateHolder

NamingContainer

Music stuff

2010-10-23T18:50:00.003+03:00

1. technique
2. theory
3. scale vocabulary
4. chord vocabulary
5. arpeggio vocabulary
6. listening to other players
7. transcribing
8. ear training
9. solfeggio
10. learning songs
11. reading scores
12. improvising
13. composing
14. lead guitar styles
15. rhythm guitar styles
16. playing with other musicians
17. studying regularly with a teacher
18. reading music magazines
19. watching instructional DVDs
20. gear and recording
21. transposing
22. arranging

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

one year program

read scores
know all the modes - 6 months
play rock rhythm
solfeggio - 1 vol

rock rhythm in 6 weeks - 3 months
guitar masterclass 6 months
30 jazz standards - 6 monts, improv, comping, solo
pentatonic concepts 2 months
learn to play fast 2 months
1 month - path to fretboard mastery
3 months - 100 low comping phrases
3 months - 100 high comping phrases
10 original melodies 6 months
6 months - 100 blues licks
eric clapton study
10 metal songs - 6 months (jimi hendrix one and srv)
ear master daily - 10 mins at least (morning)
1 month - berklee - recognize chord progressions
solfeggio - 10 mins (daily)
transcribing 30 songs - 15 metal, 15 jazz - 6 months
folk 30 songs with lyrics - transposed also also

Monday - October the 18th

2010-10-18T11:57:00.007+03:00

62 - 82

Guide to using facelets tags

Guide to using facelets templating tags
------------------------------
ui:composition

ui:decorate same as composition just that things that are outside this tag
are not ignored

ui:define where the content that should replace ui:insert from the temmplate
begins in the template client

ui:insert is the placeholder in the template file where the content should
be inserted from the template client, if no name attribute the content that is inserted is the actual content for this tag

ui:include can be placed in template clients or template. This tag supports
parameters which you can pass to the included file

Guide to using non templating tags
----------------------------------

ui:component id="optionalComponentId"
binding="managedBeanUiComponent"
if binding not provided , one will be created in the created

anything outside this tag is not included

ui:fragment
the same as ui:component except that it wraps
a series of components inside a single parent component
before is added to the tree

ui:remove used to comment a portion of the markup

ui:debug hotkey="optionalHotKey"
pressing that key will show you the component tree
is optionalKey not specified pressing ctrl-shift-d will show the popup window

Chapter 5
Managed beans the JSF EL
------------------------

@ManagedBean(name="xxx")
public class UserBean
if no name attribute the name will be userBean

can also add it in faces-config

managed-bean
managed-bean-name
managed-bean-class
manged-bean-scope
"end" managed bean

u can actually put in the page directly
#{userBean.firstName} and it will render

@ManagedProperty(value="Jane")
this is to add an initial value to a property
in the managed bean
or in faces-config
<managed-property>
<property-name>firstName</property-name>
<value>Jane</value>
</managed-property>

showing items from lists
#{userBean.sportsInterests[0]}

for maps value="#{userBean.sportsInterests['Swimming']}"

u can also declare maps or lists as managed beans
<managed-bean>
<managed-bean-name>moreSports</managed-bean-name>
<managed-bean-class>java.util.ArrayList</managed-bean-class>
<managed-bean-scope>none</managed-bean-scope>
<list-entries>
<value>Skiing</value>
<value>Tennis</value>
<value>Rollerblading</value>
</list-entries>
</managed-bean>

u can refer other managed beans in the declaration of managed beans
<list-entries>
<value>#{moreSports[0]}</value>

this is an example using annotations
@ManaqedProperty(value="#{addressBean}")
private Address homeAddress;
@ManaqedProperty(value="#{addressBean}")
private Address shippingAddress;

u can also use params from the request
<managed-property>
<property-name>userid</property-name>
<value>#{param.userid}</value>
</managed-property>

doing the same thing with annotations
@ManaqedProperty(value="#{param.userid}")
private Address userid;

Managed beans life spans
--------------------------
there is a scope which is shorter than request
#{facesContext.attributes} (u actually put this value
for scope in faces-config)

other scopes: none, request, view, session, application
request to be avoided ?!

managed beans can reference either managed beans
with the scope none or beans with greater or equal scope span.

none - @NoneScoped (will stay as long as the bean that is referencing it)
request - available only for one http request @RequestScoped
view scope - the user stays in the same view @ViewScoped
session - @SessionScoped
application - available to all users!
customscope - @CustomScoped

u can use other annotation in the BB
@PostConstruct
@PreDestroy

JSF EL
------------------------------------
#{expr} evaluated at runtime time
${expr} evaluated at compile time

used as:

value expressions
----------------------------
#{userBean.firstName}
first looks is the value of the base is one of the implicit objects in EL
first it looks in ServletRequest getAttribute("userBean")
from the UIViewRoot calls getViewMap()
from the HttpSession calls getAttribute("userBean")
if not found calls getAttribute("userBean") on the ServletContext

setting values in mb value="#{userBean.firstName}
this happens in update model values phase
the class involved is ValueExpression
-----------------------
the EL flash

flash is an implicit object in EL
flash.serviceLevel sets or gets the var sericeLevel from the flash
scope

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

91 - at least 101

method expression - when an action is specified
u can't pass params to method expressions

action
actionListener
valueChangeListener

u can invoke arbitrary methods
and pass parameters to them

<h:link outcome="page02" value="Link with query parameters">
<f:param name="word1" value="hello" />
<f:param name="word2" value="dolly" />
</h:link>

How to access backing bean programatically
ELContext elContext = context.getELContext( );
Application application = context.getApplication( );
String userid = (String) application.evaluateValueExpressionGet(context,
"#{userBean.userid}",String.class);

chapter 6 - the navigation model
--------------------------------

implicit navigation

Friday - October the 15th

2010-10-15T12:27:00.007+03:00

1. respond to the questions raised at the V12 scopes presentation

2. JSF 2 - 20 pages V

3. Presentation about what I've been reading

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

<ui:include src="menubar.xml">
<ui:param name="user" value="#{currentUser}"/> </ui:include>

u can pass params to included pages

u can use jsp and facelets

u can write pure HTML in facelets

composition using facelets

there is a template and a template client
which uses the template and defines the placeholders

this in the template
<tr><ui:insert name="body">Placeholder Body</ui:insert></tr>
this is the template client
<ui:composition template="/lnf-template.xhtml">
<ui:define name="body"><table width="70%">....</ui:define>

the jsfc attribute specifies what component should be used on the
client side

Friday - October the 15th

2010-10-15T12:27:00.006+03:00

1. respond to the questions raised at the V12 scopes presentation

2. JSF 2 - 20 pages V

3. Presentation about what I've been reading

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

<ui:include src="menubar.xml">
<ui:param name="user" value="#{currentUser}"> </ui:param>

u can pass params to included pages

u can use jsp and facelets

u can write pure HTML in facelets

composition using facelets

there is a template and a template client
which uses the template and defines the placeholders

this in the template
<ui:insert name="body">Placeholder Body</ui:insert>
this is the template client
<ui:composition template="/lnf-template.xhtml">
<ui:define name="body"><table width="70%">....
</table></ui:define></ui:composition></ui:include>

the jsfc attribute specifies what component should be used on the
client side

anything outside the <ui:define/> is ignored in a template client file

JSF2 complete reference

2010-10-13T12:21:00.007+03:00

28 - 55

restore view
the tree is kept in FacesContext

apply request values
processDecodes on the UIViewRoot
only ValueHolder uiComponents can hold values
only EditableValueHolder components can have their value changed
the values are kept on each component in submittedValue
the ones that have events implement ActionSource interface
events are queued at this phase
immediate attribute makes it skip this phase

process validations
data conversion
processValidators on the UIViewRoot
when a validation or conversion fails the valid attribute is set to false and
a FacesMessage is queued on the FacesContext

update model values
this is where the managed beans properties that were bound get updated
processUpdates on the UIViewRoot
processUpdates is overridden in the UIInput components and call an extra
updateModel method

invoke application
this is where the custom action code is called
processApplication on the UIViewRoot
call broadcast on each UIComponent that implements ActionSource
navigation happens here also
NavigationHandler calls handleNavigation
if the outcome which was received by the NavigationHandler
is registered -> facesContext.setViewRoot is called
h:link is the same as h:commandLink with attribute imediate set to true
if immediate is set for EditableValueHolder then its validations
occur in apply request values phase

render response
encode methods happen here
saving of the current state of the View

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

phase listeners - class which implements PhaseListener and
it's declared in faces-config or added programmatically
registered on the lifecycle instance

work - october the 13th (Wednesday )

2010-10-13T11:04:00.003+03:00

1. respond to the questions raised at the V12 scopes presentation

2. read V12 guidelines V

3. JSF 2 - 20 pages V

BIG GOAL 12.10.2010 - 1 DEC 2010

2010-10-12T11:37:00.001+03:00

Read JSF2 - Complete reference.pdf

every Friday - a presentation on what I have been reading the whole week

Friday from 16.00 to 17.00

work tuesday - oct the 12th 2010

2010-10-12T11:34:00.003+03:00

1. loadobjectives testing estimate - V

2. read JSF 2 - 8 - 29 V

3. respond to the questions raised at the V12 scopes presentation

4. read V12 guidelines

week - for practicing 11-17 oct 2010

2010-10-11T11:41:00.007+03:00

ionian, dorian, mixolydian - daily (in C , G, Bb, Eb)
circle of fifths X7 - daily
IIm - V - I - daily

low comping 3 lessons
read two tunes and learn them
write the it never entered my mind solo
solo for sweet home alabama
solo for ac dc, highway to hell
jimmy hendrix - little wing

technique - more accurate alternate picking
watch how to play fast and apply
watch fretboard mastery and apply

------------------------------------
grateful dead
low rider
tequila
blues traveler
fire on mountain - grateful dead
dead - god and grove
-------------------------------
monday - C,G,Bb ionian, dorian, mixolydian
circle of fifths X7 - almost getting it in time
technique - still weak upstroke but definitely getting better
-------------------------------
tuesday - C,G,Bb ionian, dorian, mixolydian
circle of fifths X7 - not that much
a little picking - was not that comfortable ,
watched a chapter on how to play faster
discovered that making trills with your pinky helps strengthtening
your left hand
Bb is just like C just 2 frets down :)
------------------------------
wednesday - nothing

------------------------------
thursday - X7 in circle of fifths
ionian , dorian in C ...only C because I got caught up on technique
doing pinky exercises
experimented a little phrygian over minor chords
experimented a little Ab melodic minor over G7 chord
very weak upstroke, have to work more on this
Observed that I am significantly slower if I begin on upstroke a scale
Observed I do hold my breath when shifting to a new position.
This has to be corrected.
When doing X7 observed that for the A form I wasnt visualizing the root.
I watched a little path to fretboard and I'm thinking I should give it one month
or two.
The beautiful thing about this fretboard mastery is the introduction
when it is mentioning all aspects of music. There are a lot more than
were in my study plan. I should revise it.
THE KEY IS DISCIPLINE.

plan for 2 weeks, all keys for ionian dorian mixolydian
learn 1 song for voice, 1 for rock, 1 for jazz
do IIm - V - I for all keys
transcribe one melody
compose 1 melody
low comping
(low comping 3 lessons
read two tunes and learn them
write the it never entered my mind solo
solo for sweet home alabama
solo for ac dc, highway to hell
jimmy hendrix - little wing)

observed that there is a way to hold the pick more firmly to achieve
greater speed and to always be prepared to sound artificial harmonics

overall - a very good day :)

work - october the 11th

2010-10-11T11:38:00.002+03:00

- fix everything in loadobjectives
- presentation for the next tech article
- find answers to the questions raised at the previous presentation
- read 20 pages of jsf 2

Jimmy Bruno 1

2010-09-20T22:56:00.004+03:00

1st lesson

6v2 5v2 - arpeggios on those 7Maj (circles of fifths)
over II V I - target the root

6v4 5v4

6h2 5h2

connect them

over II V I - third, fifth, seventh, 9th, 11th, 13th

dorian positions - in all 12 keys again ,
target the root of the II V I

play scale in thirds, groups of 4

chords Dom7 64321 (circles of fifths) - II V I

rey low comping also (tomorrow one tune by ear and one solo by ear )

single note , accented up, triplet - metronome 95 - downs 140

Melody1

2010-08-30T22:54:00.003+03:00

scales (caged, 3 notes) - caged 55 know the roots, know the thirds
pentatonics
arpeggios - Cmaj 7 in caged http://www.youtube.com/watch?v=ivE3hdm_tws&feature=related
modes
scales in intervals
scales for chords

Technique1

2010-08-30T09:45:00.004+03:00

accuracy ( villa lobos etude no 1 with pick ) - 70pm(10min (4
in a row) V
- faster one string ( triplets at 75, 16th at 70bpm) V
- bending (9th position onb - bending one tone D to E , on G 5th position - G to A)
- downstrokes (Em,70bpm 8thnotes, triplets - accenting more)- run to the hills 120 bpm
- stretches ( Xes 1234,2345,3456 with sweep picking) at 70/2

reading notes - TIO

2010-08-29T20:45:00.002+03:00

comfort zone, learning zone, panic zone

1. It is actively designed specifically to improve performance, often with a teacher’s help.
2. Identify elements that need to be improved then work intently on them.
3. It can be repeated a lot
4. Feedback on results is continuously available
5. It’s highly demanding mentally
6. It isn’t much fun.
7. No automatic, performance must be conscious.

We insistently seek out what we’re not good at. Then we identify the painful, difficult activities that will make us better and do those things over and over.

Great performers never allow themselves to reach the automatic, arrested development stage in their chose field. … Ultimately the performance is always conscious and controlled, not automatic.

weekly plan

2010-08-29T20:27:00.004+03:00

3hours music daily (180 min) - week days
(7am - 8am)
(8pm - 10pm) or(10pm - 12pm)
20 min - each aspect

1 programming (45 min reading, 15min repeating) - during work or 10pm - 11pm

bb - 2 hours

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

weekends
same as a normal working day
5 hours music
3 hours programming

-----------
programming
1 hour coding, 1 hour reading, alternatively -week days
weekends 1 hour reading, 2 hours coding your ideas

every week on Sunday - counting the hours spent
, assessing performance in every aspect

general skill plan

2010-08-29T20:08:00.002+03:00

Harmony
chords - jazz guitar masterclass
low comping
high comping
substitutions (tritone substitution)
take simple tunes and make them jazzy
take jazz standards and make them simple

Melody
scales (caged, 3 notes)
pentatonics
arpeggios
modes
scales in intervals
scales for chords

Ear
solefeggios
ear master daily
transcribe in guitar pro
transcribe harmony with guitar and without
berklee transcribe harmony
singing tunes

Technique
develop tremolo picking
develop string skipping
sweeping
legato all combinations
learn flight of the bumblebee
accenting in 2,3,4,5,6,7

Composition
compose tunes with harmony defined
compose tunes with melody defined
compose tunes with lyrics defined
write own tunes with lyrics
analysis of Beatles
analysis of Bach

Interpretation
bends
playing in legato
playing crescendo, diminuendo
effects

Learning tunes
101 blues licks
rock tunes
Bach
Beatles

Reading
jazz standards
Bach
find material for progressive reading

Rhythm
playing against time
play scales in diff rhythms
study rests
odd groupings (5,6,7)
odd time signatures

26 aug 2010

2010-08-26T11:23:00.003+03:00

the quotes for automation
my defect with suggests
the message change
the run button
octav's defect
snapshot isolation
tests
the addit field null in input Octav

smth

2010-08-08T16:57:00.040+03:00

dont add the period V
all mf in input validation V
test upgrade script V
test that the required addit fields are represented as required V
add in the build the upgrade script and commit in processes V
add 1 superscript instead of dagger V
verify all the logic definitions validations V

add participant position not loaded validation the Vapi validation V
modify the addit fields (the way you get the label)Octav V
modify the messages and details so that details go to details V
modify the suggests Octav
make input records sp test
erase the editable field when there no value in input V
add order (in validations and in addit fields in definition)
modify the diagram - talk to Irina Creo V
comment defects in QC V
add the messages for rejected records V
when adding new addit field if you press back and next u see null field in input[null field in input Octav]
lacra and double quotes and the underscore V
add snapshot isolation Samir
add Pavaleanu's message 4.1.1.2 extra space
add message change

Map participantAttributeValuesMap = currentParticipant.getAttributeValues();
for (Integer paId : paIds) {
Object paValue = null;
if (paId.equals(ParticipantAttributesSystemParameters.PARTICIPANT_TYPE_SYSTEM_PARAMETER.toInt())) { //the hidden "_participant type"
paValue = currentParticipant.getAttributeNameValueMap().get(ParticipantAttributesSystemParameters.PARTICIPANT_TYPE_SYSTEM_PARAMETER.getName()).getValue();
} else {
paValue = participantAttributeValuesMap.get(paId).getValue();
}
paBuilderValueObjects.add(new ExpressionBuilderValueObject(paValue, FieldType.PARTICIPANT_ATTRIBUTE, paId));
}

2010-08-07T14:12:00.001+03:00

food once,
gima,
curatenie,
sala,
munca,
mancare,
chitara

de facut

2010-08-06T15:03:00.007+03:00

dont add the period V
make input records sp test
talk about adding a result INPUT COUNT
all mf in input validation V
test upgrade script V
test that the required addit fields are represented as required
add in the build the upgrade script and commit in processes

1 hour

2010-08-05T09:26:00.002+03:00

accuracy ( villa lobos etude no 1 with pick ) - 65bpm (10min (5
in a row)
- faster one string ( triplets at 75, 16th at 70bpm)
- bending (9th position onb - bending one tone D to E , on G 5th position - G to A)
- downstrokes (Em,70bpm 8thnotes, triplets - accenting more)
- stretches ( Xes 1234,2345,3456 with sweep picking) at 65/2

1 hour

2010-08-03T09:14:00.003+03:00

- accuracy ( villa lobos etude no 1 with pick ) - 60bpm (10min (6
in a row)
- faster one string ( triplets at 75, 16th at 65bpm)
- bending (9th position onb - bending one tone D to E , on G 5th position - G to A)
- downstrokes (Em,65bpm 8thnotes, triplets - accenting more)
- stretches ( Xes 1234,2345,3456 with sweep picking) at 65/2

1 month - 1 hour

2010-08-02T08:42:00.008+03:00

- accuracy ( villa lobos etude no 1 with pick ) - 55bpm (10min (4 in a row)
- faster one string ( triplets at 70, 16th at 60bpm)
- bending (9th position onb - bending one tone D to E , on G 5th position - G to A)
- downstrokes (Em,60bpm 8thnotes, triplets - accenting more)
- stretches ( Xes 1234,2345,3456 with sweep picking)

- first lick in blues (101 riffs)
http://www.youtube.com/watch?v=aNynowMVy4Q
----------------------------
ideas
take a 1625 and do all the higher voicings

THE SHIT http://www.youtube.com/watch?v=NBRLUz0j_5A&feature=PlayList&p=59C7F585E353EE3C&index=6&playnext=1

GP - 1st month

2010-07-31T22:38:00.005+03:00

- accuracy ( villa lobos etude no 1 with pick ) - 50bpm (10min)
- faster one string ( triplets at 70, 16th at 70bpm)
- bending (9th position onb - bending one tone B to C #, on G 5th position - D to E)

--------
ideas

http://www.ultimate-guitar.com/lessons/correct_practice/how_to_increase_speed_using_your_practice_time_and_a_metronome.html

learn solo for sweet home Alabama
record improvisation on glory box
two strings arpeggios like here
http://www.youtube.com/watch?v=MxRzO6ftlqA&feature=related
look at the arpeggios dvd
how to record using gt 10

GP - 1st month

2010-07-31T22:06:00.003+03:00

Guitar playing technique
1. accuracy when changing strings - metronome
2. faster one string picking - metronome
3. bends - metronome
4. faster down strokes - metronome
5. stretches - metronome

Musical knowledge on guitar
1. learn blues licks
2. arpeggios (rock,jazz)
3. scales for chords
(guthrie govan, jazz masterclass, joe pass, scott henderson)
4. chords (jazz master class, lowcomping, scott henderson)
5. modes

Ear training
1. find a teacher
2 the book
3. ear master (intervals, time keeping)
4. transcribe children songs in guitar pro after writing them on paper
5. solfeggio (record and then try to see if you do mistakes)
6. learn a song
7. write a rhythm

Composition
- write a song a week (two verses, one chorus, one bridge)
- analyze the song you learned
- record the song
- transcribe in music sheet
- orchestrate it
- record yourself improvise on blues

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

How much time do we have?
3 hours a day for work days - 15 hours
4 hours in weekend - 8 hours
---
total 23 hours

Work days
8am - 9am 1 hour
no workout days - 20.00 - 22.00
workout days - 22.30 - 0.30

weekend
10 - 12
16 - 18

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

work in 30 min chunks
10 minutes for every aspect in general
keep a diary for progress

How to do better - deliberate practice

2010-07-31T22:03:00.002+03:00

1. Search for a teacher
2. Practice to improve. Decide what you need to improve and improve it.
3. Comfort, learning, panic. Stay in learning as you progress.
4. It can be repeated a lot
5. Feedback on results is continuously available.
6. It's highly demanding mentally
7. It isn't much fun.

2nd month

2010-07-29T12:25:00.001+03:00

MONTH 2- BASIC ONE DAY SPLIT WHOLE BODY PROGRAM #2
Bodypart Exercise Set 1 Set 2 Set 3
Compound Legs Barbell Squats 12/ 10/ 8/
Compound Legs Dumbbell Lunges 12/ 10/ 8/
Hamstrings/Lower Back Romanian Deadlifts 12/ 10/ 8/
Calves Seated Calf Raises 12/ 10/ 8/
Chest Incline Dumbbell Presses 12/ 10/ 8/
Back Seated Rows 12/ 10/ 8/
Shoulders Dumbell Lateral Raises 12/ 10/ 8/
Biceps Alternate Dumbbell Curls 12/ 10/ 8/
Triceps Overhead Dumbbell Extensions 12/ 10/ 8/
Abdominals Reverse Crunches 15/ 15/ 15/
*Fill in the amount of weight you used in the space left blank after the amount of reps.
Ex: Compound Legs Barbell Squats 12/100 10/90 8/80
This would mean that you did 12 reps with 100 pounds on your first set,
10 reps with 90 pounds on your second and 8 reps with 80 pounds on your third.

mashed potatoes

2010-07-25T15:27:00.006+03:00

ok, so

weight condition and number of decimals V
additional fields V
score pb V
participant comments V
manager comments V
objectives approved
scores approved
objectives levels approved
scores levels approved

Short program

2010-07-18T20:36:00.002+03:00

20:50 program next hour

21 create classes for execution of stored procedure
obj_pod_20071112_0140

1st month - 5(080710)

2010-07-08T11:26:00.001+03:00

WRK

2010-07-06T10:38:00.001+03:00

processlogs and showSmthElse

1st month - 2 (010710)

2010-07-02T10:36:00.003+03:00

2.

Compound Legs Leg Press 12/ 10/ 8/ (100,120,150)
Quads Leg Extensions 12/ 10/ 8/ (56,64,72)
Hamstrings Lying Leg Curls 12/ 10/ 8/ (56,64,72)
Calves Standing Calf Raises 12/ 10/ 8/ (56,64,72)
Lower Back Hyperextensions 12/ 10/ 8/ with 5kg
Chest Barbell Bench Press 12/ 10/ 8/ with 10kg, 9,8,5
Back Latissimus Pulldowns 12/ 10/ 8/ with 40kg 12,10,6
Shoulders Dumbbell Overhead Press 12/ 10/ 8/ no weights 10,9,6
Biceps Barbell Curls 12/ 10/ 8/ bar + 5kg,bar +10,bar+ 10
Triceps Rope Tricep Pushdowns 12/ 10/ 8/ (25,25,25)
Abdominals Crunches 15/ 15/ 15/ (15,15,15)

1st month

2010-06-28T15:34:00.002+03:00

1.

Compound Legs Leg Press 12/ 10/ 8/ (90,110,130)
Quads Leg Extensions 12/ 10/ 8/ (48,56,72)
Hamstrings Lying Leg Curls 12/ 10/ 8/ (48,56,72)
Calves Standing Calf Raises 12/ 10/ 8/ (48,56,72)
Lower Back Hyperextensions 12/ 10/ 8/ with 5kg
Chest Barbell Bench Press 12/ 10/ 8/ with 10kg, 10,6,5
Back Latissimus Pulldowns 12/ 10/ 8/ with 40kg 10,8,30kg 10
Shoulders Dumbbell Overhead Press 12/ 10/ 8/ no weights 8, 6, 4
Biceps Barbell Curls 12/ 10/ 8/ zbar + 5kg, zbar +7.5, zbar+ 7.5
Triceps Rope Tricep Pushdowns 12/ 10/ 8/ (20+ , 20+ , 20)
Abdominals Crunches 15/ 15/ 15/ (15,15,13)

hia

2010-06-22T12:10:00.002+03:00

we just learned about entity modes

MAP, POJO , DOM4J

entity type vs value type

entity type has its own database identity

value type have no database identity (string, integer, address, monetaryAmount)

Today, 22 june

2010-06-22T11:30:00.001+03:00

20 pages hia.
go into loadobjectives xml parameters.
clean up the apartment.
use the washing machine.
1st day of a non smoker.

Ok, new beginning

2010-06-22T11:26:00.002+03:00

Just decide.

Qeta again?
Vlad again?
Solfegii?
Sala?
Smoking?
Drinking?
Go public?
Do the wicket?
Do the JSF 2.0?
Do the Hibernate?

hia 1

2010-06-08T11:27:00.002+03:00

the mismatch

the problem of granularity
the problem of subtypes
the problem of identity
problems related to associations
the problem of data navigation

plan load objectives

2010-05-09T19:20:00.001+03:00

- understand all details about the process in processing
- send comments to virgil
- start the developing

- send a lot of cvs

idee

2010-05-02T22:57:00.000+03:00

la7

daca m-ai cunoaste dinainte
m-ai iubi la fel

moving list

2010-04-30T17:01:00.002+03:00

To take

4 guitars
books
microwave
pc
2 monitors
laptop
weights

some clothes

need to throw useless stuff(books, clothes)

18-04-2010

2010-04-19T11:17:00.001+03:00

1 ear master

lo process

2010-04-17T16:50:00.003+03:00

reach to the process page

think and write a model

input ?

get to know how to map

1. learned to implements ProcessDefintionManagedService

2. fixing shit...dumb bug , getId on the defintion was returning null

17-04-2010

2010-04-17T16:49:00.001+03:00

1 ear master (only 5 from completing interval identification)

16-04-2010

2010-04-17T16:48:00.001+03:00

1 ear master

15-04-2010

2010-04-15T19:02:00.006+03:00

1 ear master

Plan for lop

tonight:
read doc twice, and decide what other docs to read

find a process that resembles this (just find) and
find an easy process and walk through the code

start dev: give

DOC:

diff between current previous period and absolute

Summary:

First page

A)input : records

B)logic : 3 parts

1. obj plan

2. specify if you update , load new objectives, remove objectives
not in input (all are based on what is specified in the Definition ?)

3. the fields as mapped

Edit Logic:

wizard two pages

objective plan

validations (period of the objective plan can be determined?)
in use discussions

field mapping page

Plan for programming skills

2010-04-13T16:10:00.002+03:00

hibernate (know many-to-one , one-to-many, many-to-many, user-type, hibernate
template, transaction(ACID))

spring ( injecting dependencies, ioc container)

- experience in a similar position
- experience with OOP, UML and design patterns
- efficiency in Java and SQL languages
- J2EE framework solid background
- experience with web applications architecture and development
- knowledge in JBoss, Struts, Hibernate, CVS, XML, web services, JUnit and Ant

13-04-2010

2010-04-13T16:09:00.002+03:00

1 ear master

12-04-2010

2010-04-13T16:09:00.001+03:00

1 ear master

11-04-2010

2010-04-12T09:29:00.000+03:00

X (4 ear master , metro 110 16th (legato and picking)

10-04-2010

2010-04-10T23:52:00.002+03:00

X (2 ear master , metro 105 16th (legato and picking)

08-04-2010

2010-04-08T19:51:00.002+03:00

some ear master (and make sure u can sing chromatic)

guitar (scales and rehearsal baby I love your way, metallica )

sql joins and decide on a good design pattern book.

the morning

2010-02-18T00:54:00.005+02:00

a) note names - drill 2
b) tonic shapes
c) caged - drill 2
d) pentatonic shit - some new patterns
e) maiden
f) deep purple - smoke on the water

plan again

2010-02-14T22:42:00.005+02:00

so u know :
ALL KEYS

3 notes per string

now do it caged

pentatonic - two patterns per day

modal - do backing tracks for every mode (Gambale , Machacek)

chords - all chords in all keys ( 1st day - Maj 7, m7 , 7)
----------------------------------------------------------

after this week we're going to arpeggios, 2-5-1 in every key ( Danny Gill)
continue with chords
scales for chords - Joe Pass , Scott Henderson

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

THE PATH TO FRETBOARD MASTERY
1) NOTE NAMES
Goal: know all notes on the fretboard

observations
a)go behind the nut to play E open string
b)always go to the nearest note called.
c)use always first finger only

drill 1: call notes and work on each string at a time 6,5,1,4,3,2.
drill 2: try in a position to call random note names.

2) TONIC SHAPES & 3) TRANSPOSITION DRILLS
Goal: See the diamond shape for every key

drill 1: pick a tonic shape and then pick a note.
If possible do it in both octaves.
Stay with a tonic shape until you know it.

drill 2: pick a key and play all tonic shapes.

drill 3: pick a position and then pick a random note and play the tonic position
you find in that position.

4) MAJOR SCALE TEMPLATES (or CAGED)
drill 1: play all shapes for a key. Remember to associate the shape
for the scale with the tonic shape also.

drill 2: pick a key and an interval in a shape.
For example all the 2s - , all the 5s etc.
You can do it with note names also.

drill 3: pick a key and then pick an interval.
For example play all the 6s in C (A).

5) CHORD SHAPES

Drill for CAGED

09 feb - 2nd day of smth

2010-02-09T16:20:00.000+02:00

1) tm?!

08 feb - 1st day of Rain

2010-02-08T20:18:00.003+02:00

ALL in circles of 5ths and 4ths
1) learn 3 notes per string
2) learn pentatonic
3) learn CAGED

4) Metallica solos - Enter Sandman
5) Solfegii
6) Ear Master

7) Chords and applications??
8) Composition - imi place sa fiu in lucruri complicate

Master that riff

2010-01-05T12:15:00.003+02:00

1) satch boogie
2) lenny kravitz - always on the run
3) lenny kravitz - american woman
4) pantera - walk
5) metallica - seek and destroy
6)

go go go

2010-01-04T11:18:00.002+02:00

koop - strange love feat. hilde louise - aceleasi tobe dar dupa 2-3 masuri niste distors

songs to remember 1

2009-12-15T13:42:00.002+02:00

police - message in a bottle
police - roxanne
the cure - friday i'm in love
the cure - just like heaven

wrist mo

2009-12-02T11:56:00.000+02:00

Acorduri

2009-11-24T22:29:00.002+02:00

F7 Fmaj7
Fm
F6 = Dm7
Fm6 = Dm7b5 = Bb9 w/o Bb

Fm7b5
F7b5
F7#5

vineri 20 noiembrie

2009-11-20T15:26:00.004+02:00

do

solfeggio quinta

all chords

CAGED on backing track - regular major and pentatonic

tea and susana (adriano celentano)

ear master

etp - songs to spell

2009-11-11T14:57:00.002+02:00

stefan , stefan domn cel mare
si daca dragoste nu e
copilita fara minte
margineanu femei femei

etp2 10-11-09

2009-11-11T00:59:00.003+02:00

20 min Bb harmonic intervals recognition
20 min solfegio - jules arnoud (terta mare si mica)
20 min saraca inima me

etp suggestions

2009-11-05T11:51:00.004+02:00

make the pinch harmonic
http://www.youtube.com/watch?v=60wlk7VamqQ&feature=fvst

or this
http://www.youtube.com/watch?v=5I5O8P-r5Rk

http://www.youtube.com/watch?v=QA62zY6G8Hw&feature=PlayList&p=051D50BB80DEA091&index=3&playnext=2&playnext_from=PL

red house
http://www.youtube.com/watch?v=CjOQ9r35uiU&NR=1&feature=fvwp

rsp - suggestions

2009-11-04T13:12:00.000+02:00

sonatas and partitas by Bach

ip1 03-11-09

2009-11-04T02:03:00.001+02:00

howard roberts - beginning his method

rsp1 03-11-09

2009-11-03T23:36:00.005+02:00

b loure suite no.4 - couple of rows

etp1 03-11-09

2009-11-03T22:07:00.004+02:00

20 min Bb harmonic intervals recognition
20 min solfegio - jules arnoud (secunda mare si mica)
20 min transcription - desteapta-te romane (1st verse)

Technique plan

2009-10-29T15:27:00.002+02:00

80 min
-------

40 min oliver gannon (2 X 1st. low comping strings,1X 2nd high comping strings )
20 min blues (101 blues licks )
20 min alternate picking ( lick library continuing into guthrie govan )