It covers GlassFish administration. Then it talks about Java web technologies -- servlets, JSP, JSP STL, JSF. Also discusses database connections, Java Messaging Service, security of applications (you can find more about it in GlassFish Security book). The books also talks about EJBs and new possibilities in Java EE 6 -- contexts and dependency injection. In the last part it discusses JAX-WS and JAX-RS web services. And everything is accompanied with information how to do that with GlassFish application server.

I would very much recommend it to novice Java EE developers or just to developers, who want to have a glance on Java EE web technologies, JMS, Java EE 6 dependency injection, web services and how all that is configured in GlassFish application server. I would say, it is a crash course into Java EE.

The book is not covering each section is deep detail. But gives a broad view on different Java EE possibilities.

The book is full of working examples! What I very much like about it, is that it not only talks about the latest Java EE 6 technologies. But also briefly covers how application can be configured in order to work with older standards.

From the table of contents I conclude that this book gives quite broad view on Java EE technologies and how to use them with GlassFish v3 application server. Although it is not covering some particular technology very detailed.

First chapter is about GlassFish -- how to setup it and configure. The following ones are about Java web technologies: servlets, JavaServer Pages, JSP Standard Tag Library, JavaServer Faces. Next, books talks about Java Messaging Service and security. Last chapter are the most interesting, in my opinion: Enterprise JavaBeans, Contexts and Dependency Injection and Web Services.

Anxious to read it!

So if you are just about to design or develop complex Java EE application, I would recommend to take a look into this book to at least grasp the ideas about security management. Beside this, book also covers topics of easy security policies migration, which also may be somewhat interesting in our changing world.

And again, thanks PACKT for publishing yet another wonderful book!

I was granted a book from Packt about GlassFish Security. And that is something we want to improve in our products!

The book is about security in Java EE with EJB, Application Client modules and all the friends. Security in GlassFish is a central point of this book. And what is more, there are plenty of real world code and configuration samples. More information about the book can be found on dedicated page on Packt website.

java.lang.NullPointerException
	at org.glassfish.appclient.client.acc.ACCLogger$1.run(ACCLogger.java:149)
	at java.security.AccessController.doPrivileged(Native Method)
	at org.glassfish.appclient.client.acc.ACCLogger.reviseLogger(ACCLogger.java:146)
	at org.glassfish.appclient.client.acc.ACCLogger.init(ACCLogger.java:93)
	at org.glassfish.appclient.client.acc.ACCLogger.(ACCLogger.java:80)
	at org.glassfish.appclient.client.AppClientFacade.createBuilder(AppClientFacade.java:360)
	at org.glassfish.appclient.client.AppClientFacade.prepareACC(AppClientFacade.java:247)
	at org.glassfish.appclient.client.JWSAppClientContainerMain.main(JWSAppClientContainerMain.java:83)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at com.sun.javaws.Launcher.executeApplication(Unknown Source)
	at com.sun.javaws.Launcher.executeMainClass(Unknown Source)
	at com.sun.javaws.Launcher.doLaunchApp(Unknown Source)
	at com.sun.javaws.Launcher.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)

You are not alone! We have rewritten one of our products using Java EE 6 features. And since we had to use GlassFish v3 in order to run this application, we had to migrate other applications too. And then this nasty bug was discovered...

Bug on official GlassFish website:
https://glassfish.java.net/issues/long_list.cgi?issuelist=11494

It is fixed in night builds. So currently we just sticked to a specific version of night build in order to have applications working. According to information on the internet (for example http://blog.eisele.net/2010/03/glassfish-product-roadmap-updates.html) release of GlassFish v3.0.1 will be only this summer.

For example if we have a Pencil with a composite key consisting of color and thickness:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "pencils")
public class Pencil {

  @Id
  @Column(name = "color")
  private String color;

  @Id
  @Column(name = "thickness")
  private String thickness;

  ...

The reason is that I received an email from Bill Shannon -- Java EE specification lead, who kindly asked me to use "Java EE" instead of "JEE". He provided following sources for Java naming:

• http://www.java.com/en/about/brand/naming.jsp
• http://www.theserverside.com/news/thread.tss?thread_id=35561

I really respect his opinion and appreciate his feedback. So from now on I will use "Java EE" to mean "Java EE".

For instance you want to inject and object which depends on some input. In current case let it be Pencil object, which needs to be initialized with color.

public class Pencil {
  private Color color;

  void init(Color color) {
    this.color = color;
  }

  public void draw() {
    //
  }
}

In this case when you inject the Pencil, you have to call init(Color) explicitly, which is kind off error-prone. What you can do is create a PencilProducer which would create Pencil objects with desired color.

public class PencilProducer {
  @Inject private Instance pencilInstance;

  public Pencil produce(Colour color) {
    Pencil pencil = pencilInstance.get();
    pencil.init(color);
    return pencil;
  }
}

In this case PencilProducer will create new Pencil object every time it is called. And in the application you simply inject PencilProducer and call produce method when needed.

This may seem to be too straight and dirty, but hey -- no new keyword!

Say, you have a @Singleton

package example;

import java.util.Properties;

import javax.annotation.PostConstruct;
import javax.ejb.Singleton;

@Singleton
public class AppParamsLoader {

  private Properties props = null;

  @PostConstruct
  void init() {
    props = loadProperties();
  }

  public String getParam(String paramKey) {
    return props.getProperty(paramKey);
  }

  void loadProperties() {
    // ..
  }
}

You can use EJBContainer for your integration testing:

package example;

import javax.ejb.embeddable.EJBContainer;
import javax.naming.Context;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class AppParamsLoaderTest {

  private static EJBContainer container;
  private static Context namingContext;

  private static AppParamsLoader appParamsLoader;

  @BeforeClass
  public static void setUp() throws Exception {
    container = EJBContainer.createEJBContainer();
    namingContext = container.getContext();
    appParamsLoader = (AppParamsLoader) namingContext.lookup("java:global/classes/AppParamsLoader");
  }

  @AfterClass
  public static void tearDown() throws Exception {
    container.close();
  }

  @Test
  public void testAppParamsLoader() {
    // ..
  }
}

There is a way to initialize the container through maven:
http://blogs.sun.com/alexismp/entry/glassfish_embedded_and_javadb_embedded