from Pocket http://ift.tt/1fqUYHM
In this example creating a custom Expandable ListView with parent and child rows. parent rows contains texts,images and a checkbox. child rows contains texts,images. Creating custom adapter to create Expandable ListView rows . 1. Create Model classes for parent rows(Parent.
World Cup Brazil 2014
The Android section has just been updated with a new app.
See the matches time in your time zone.
Soon there will be more updates like new features…
Feel free to comment and rate the app.
from Pocket http://ift.tt/1dupHCI
Watch this short movie to see it in action. In its latest incarnation, available from the link above, you can reverse engineer a diagram from existing JPA sources, which is also amazing, and let’s you use the JPA modeler on old sources, i.e.
from Pocket http://ift.tt/1iTWXSE
Event-driven programming can be overwhelming for beginners, which can make Node.js difficult to get started with. But don’t let that discourage you; In this article, I will teach you some of the basics of Node.js and explain why it has become so popular. To start using Node.
In this post I will explain you one simple way of using interceptors in Java EE.
We have a simple java project that only displays a name wich is setted in the Controller class by the init method. But as you will see next, the final result it’s not the name that is setted by the controler, because we have an interceptor that changes the name behind the scenes.
The index page index.xhtm makes a server request to display the name. But that request is going to be intercepted by our interceptor MyInterceptor.java. Then who makes the request to the controller is the interceptor and if the response is of the type String it changes it to another string. When the page renders it will show not the response from the controller but the object that our interceptor returns to it.
And that’s it. Even without the final user knows nothing about it, the response has been manipulated by our interceptor.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
<?xml version='1.0' encoding='UTF-8' ?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://xmlns.jcp.org/jsf/html"> <h:head> <title>Facelet Title</title> </h:head> <h:body> #{controller.name} </h:body> </html> |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
package pt.joaobrito.controller; import javax.annotation.PostConstruct; import javax.enterprise.context.RequestScoped; import javax.inject.Named; import pt.joaobrito.annotation.LogToConsoleAndModifyResult; @Named @RequestScoped @LogToConsoleAndModifyResult public class Controller { private String name; public Controller() { } @PostConstruct public void init() { this.name = "John Doe"; } public String getName() { return name; } } |
Note that in line 10 we have a special annotation. This marks this bean to be intercepted, as you will see next. The code in the 20th line, just sets the variable name to John Doe.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package pt.joaobrito.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import javax.interceptor.InterceptorBinding; @Inherited @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @InterceptorBinding public @interface LogToConsoleAndModifyResult { } |
This is a simple annotation class (out of the scope of this post, for now). The important thing here is the @InterceptorBinding annotation.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
package pt.joaobrito.interceptor; import java.util.logging.Level; import java.util.logging.Logger; import javax.interceptor.AroundInvoke; import javax.interceptor.Interceptor; import javax.interceptor.InvocationContext; import pt.joaobrito.annotation.LogToConsoleAndModifyResult; @Interceptor @LogToConsoleAndModifyResult public class MyInterceptor { @AroundInvoke public Object interceptAndLog(InvocationContext ic) throws Exception { Logger logger = getLogger(ic); // this is executed before the method being intercepted logger.log(Level.INFO, "before the method being intercepted..."); // the object returned after the execution of the intercepted method Object result = ic.proceed(); // if the intercepted method returns a String, we can modify it if (result instanceof String) { // this is executed real result of the intercepted method logger.log(Level.INFO, "the real result of the intercepted method is: " + (String) result); // now we change the result without the final user knows that the method is being intercepted result = "Jane Doe"; } try { // we return the modified object, or the original (if it was not a string) return result; } finally { // this is executed after the method being intercepted logger.log(Level.INFO, "after the method being intercepted... thne name is: " + (String) result); } } private Logger getLogger(InvocationContext ctx) { return Logger.getLogger(ctx.getMethod().getClass().toString()); } } |
In the MyInterceptor class we have 3 important annotations:
@Interceptor (line 10),
@LogToConsoleAndModifyResult (line 11) and the
@AroundInvoke (line 14).
The first one makes this bean an interceptor. The second, marks this interceptor to intercept all methods in classes annotated with the the same annotation. The last one, marks the method that is going to manipulate all the data.
Note that this method must returns an Object and as a parameter it takes the invocation context.
First we have a logger that prints out to the console a message before the interception. Then with the help of the invocation context, it lets the original method to proceed and keeps the result. Then it prints again to the console the real name returned by the controller (John Doe). After this, it changes the return value to Jane Doe, that is exactly what is going to be displayed in the page as the final result.
|
1 2 3 4 5 |
<beans> <interceptors> <class>pt.joaobrito.interceptor.MyInterceptor</class> </interceptors> </beans> |
Finally, in order to use interceptors we must register them in the beans.xml file (line 3). Another possibility is to annotate the controller with @Interceptors({MyInterceptor.class}) but this approach is not recommended.
Here are the three messages sent to the console.
As you can see here the displayed name isn’t John Doe, as you might expect, but the modified result: Jane Doe.
Feel free to comment.
In this post I will show you how to inject an instance of Logger class using CDI (Context Dependency Injection) and SLF4J (Simple Logging Facade for Java).
To keep it simple, we only have a xhtml page (index), a managed bean (Controller.java) and the producer (LoggerProducer.java). The project configuration is as follows:
As we are using JSF with facelets, the index page looks like:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
<?xml version='1.0' encoding='UTF-8' ?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://xmlns.jcp.org/jsf/html"> <h:head> <title>CDI Producer</title> </h:head> <h:body> <h2>The name is: #{controller.name}</h2> </h:body> </html> |
In this file we simply display the name that is setted in the controller (line 10).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
package pt.joaobrito.controller; import javax.annotation.PostConstruct; import javax.enterprise.context.RequestScoped; import javax.inject.Inject; import javax.inject.Named; import org.slf4j.Logger; @Named @RequestScoped public class Controller { @Inject private Logger logger; private String name; public Controller() { } @PostConstruct public void init() { logger.info("before setting the name: name = " + name); this.name = "John Doe"; logger.info("the name was setted to: name = " + name); } public String getName() { return name; } public void setName(String name) { this.name = name; } } |
In the controller we inject (@Inject) an instance of the Logger class and print to the console the name before and after the name is setted (lines 23 and 25). CDI knows which Logger to inject because we have a class that works as a factory of Loggers (LoggerProducer) with some special annotations.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package pt.joaobrito.producer; import javax.enterprise.context.Dependent; import javax.enterprise.inject.Produces; import javax.enterprise.inject.spi.InjectionPoint; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @Dependent public class LoggerProducer { @Produces public Logger newLoggerInstance(InjectionPoint ip) { return LoggerFactory.getLogger(ip.getMember().getClass()); } } |
In the LoggerProducer class we have an annotation (@Produces) in a method that returns a Logger instance. This is enough to CDI inject a Logger when needed. Notice that in line 13 we pass as a parameter the injection point (ip) in order to get the class where the logger is being injected (in this specific case ‘Controller.class’). This is only necessary beacuse the getLogger method needs it.
Finally, here are the results (the log and the web page):
log
As you can see here, we have two lines displaying the information that we expected: first the name is null and after the set of the variable name, name = John Doe.
That’s it. It’s just that simple!
First we create a factory of loggers, then we inject them whenever we need them:
@Produces to indicate CDI what we are producing and
@Inject to inject the instance ready to use.
Notice that this methodology works with other types rather than Logger. You may inject whatever you want by simply following the above technic.
Feel free to comment.
Update: Easy Parameters
This is a tool for queries taken from logs, where we have queries and parameters unbinded. Take a look at the example.
You can also insert the parameters into the query text area instead, with the following text:
bind => [param1, param2, etc].
Feel free to use and comment.
Consider the following code snippet:
|
1 2 3 |
if (i == 15.0) { System.out.println("true"); } |
Which one of the following declarations of the variable i will compile without errors and print true when the program runs?
I will comment out the solution in the next few hours. Stay tunned.