Writing a simple application to talk to a local EJB should be as simple as

@EJB
 private SimpleStatelessEJBLocal simpleStateless;
 ...
 simpleStateless.someLocalMethod();
 ...

But what I found was a null pointer exception.
So taking the application down to the simplest app.

• One servlet.
• One statless session bean.
• Using Jdeveloper 10.1.3.5 (I can’t use 11g as I need oc4j 10.1.3.5, I know I can get around it.. more on that later)
• One local OC4J 10.1.3.5 instance.

Deploying this application and after much playing around, the null pointer was gone, and this error remained.

[Oracle Containers for J2EE 10g (10.1.3.5.0) ]

9/10/19 16:52:14.779 SimpleTwoWEB: Servlet error
java.lang.ClassCastException: com.evermind.server.ejb.StatelessSessionDefaultLocalHomeImpl cannot be cast to au.edu.rmit.its.qas.ejb.SimpleStatelessEJBLocal

This puzzled me for an hour or so, but through an obscure post on coderanch I found the problem.  It seems that JDeveloper 10.1.3.x creates web projects in web 2.4 compliance, but in order to run DI you need to run web container version 2.5.  Testing this out, I changed the web.xml from this:

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee">

changing to…

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"   xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  id="WebApp_ID" version="2.5">

And like magic is worked.

Now according to two OTN Discussions:

If you have a look at the J2EE 5 spec, the classes where DI is supported are listed on page 64.

Component classes supporting injection
Servlet: servlets, servlet filters, event listeners
JSP: tag handlers, tag library event listeners
JSF: scoped managed beans
JAX-WS: service endpoints, handlers
EJB: beans, interceptors
Java EE platform: main class (static), login callback handler

OTN  Link 1

OTN Link 2

Firstly one needs to create their entity class

@Entity
public class ImageExample implements Serializable {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Long id;

  private String MimeType;  // Useful to store the mime type incase you want to send it back via a servlet.

  // We mark up the byte array with a long object datatype, setting the fetch type to lazy.
  @Lob
  @Basic(fetch=FetchType.LAZY) // this gets ignored anyway, but it is recommended for blobs
  protected  byte[]  imageFile;

Using a simple bit of Java code taken from the Java Developers Almanac, we read the file and return it as a byte array.

public byte[] readImageOldWay(File file) throws IOException
{
  Logger.getLogger(Main.class.getName()).log(Level.INFO, "[Open File] " + file.getAbsolutePath());
  InputStream is = new FileInputStream(file);
  // Get the size of the file
  long length = file.length();
  // You cannot create an array using a long type.
  // It needs to be an int type.
  // Before converting to an int type, check
  // to ensure that file is not larger than Integer.MAX_VALUE.
  if (length > Integer.MAX_VALUE)
  {
    // File is too large
  }
  // Create the byte array to hold the data
  byte[] bytes = new byte[(int) length];
  // Read in the bytes
  int offset = 0;
  int numRead = 0;
  while (offset < bytes.length && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0)
  {
    offset += numRead;
  }
  // Ensure all the bytes have been read in
  if (offset < bytes.length)
  {
    throw new IOException("Could not completely read file " + file.getName());
  }
  // Close the input stream and return bytes
  is.close();
  return bytes;
}

We create an entity object and use the entity manager.

/*
 * Put a JPG image into the db
 */
ImageExample myExample = new ImageExample();
myExample.setMimeType("image/jpg");
file = new File("images/mushroom.jpg");
try
{
  // Lets open an image file
  myExample.setImageFile(mainCourse.readImageOldWay(file));
}
catch (IOException ex)
{
  Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}

Then we persist the entity object.

  fatController.create(myExample);

This works easily as well for PDF documents

/*
 * Put a PDF into the db
 */
 ImageExample myExampleTwo = new ImageExample();
 myExampleTwo.setMimeType("application/pdf");
 file = new File("images/studentexample.pdf");
 try
 {
   // Lets open an image file
   Logger.getLogger(Main.class.getName()).log(Level.INFO, "[Call Read]");
   myExampleTwo.setImageFile(mainCourse.readImageOldWay(file));
   Logger.getLogger(Main.class.getName()).log(Level.INFO, "[Property set]");
 }
 catch (IOException ex)
 {
   Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
 }
 fatController.create(myExampleTwo);
 Logger.getLogger(Main.class.getName()).log(Level.INFO, "The number of objects is : " + fatController.getImageExampleCount());

You can easily prove that the JPA objects were persisted to the database by reading the objects back from the database.

/*
 * Lets read the images from JPA, and output them to the filesystem
 */
 // Get the list of images stored in the database.
 List<ImageExample> images = fatController.findImageExampleEntities();
 File outfile = null;
 // Go through the list returned, looking for PDF/JPG files.
 for (int i = 0; i < images.size(); i++)
 {
   if (images.get(i).getMimeType().equalsIgnoreCase("application/pdf"))
   {
   // write out the pdf file
     outfile = new File("out/test"+images.get(i).getId()+".pdf");
     try
     {
       mainCourse.writeFile(outfile, images.get(i).getImageFile());
     }
     catch (IOException e)
     {
       Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, e);
     }
   }
   else if (images.get(i).getMimeType().equalsIgnoreCase("image/jpg"))
   {
     // write out the pdf file
     outfile = new File("out/test"+images.get(i).getId()+".jpg");
     try
     {
       mainCourse.writeFile(outfile, images.get(i).getImageFile());
     }
     catch (IOException e)
     {
       Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, e);
     }
   }
   else
   {
     Logger.getLogger(Main.class.getName()).log(Level.SEVERE, "Unknown file type");
   }
 }

If you are wondering what code I used to write it to a file, it was simple like this.

public void writeFile(File file, byte[] data) throws IOException
 {
   OutputStream fo = new FileOutputStream(file);
   // Write the data
   fo.write(data);
   // flush the file (down the toilet)
   fo.flush();
   // Close the door to keep the smell in.
   fo.close();
 }

Of course, if you were to use this in production you would add more error checking, and probably follow some better best practices. I have also skipped a lot of steps, assuming you know what you are doing