Necesito una conexión de base de datos en el servicio Web Java implementa como un bean de sesión, y no estoy seguro de que si yo hago lo correcto.

He creado una clase

public final class SQLUtils   {  
    //.....  
    private static DataSource  m_ds=null;    

    static  
    {  
        try
        {
            InitialContext ic = new InitialContext();
            m_ds = (DataSource) ic.lookup(dbName); //Connection pool and jdbc resource previously created in Glassfish  , dbName contains the proper JNDI resource name 

        }
        catch (Exception e)
        {
            e.printStackTrace();
            m_ds = null;
        }

    }

    public static Connection getSQLConnection() throws SQLException  
    {  
        return m_ds.getConnection();             
    }
}

Cada vez que necesito una conexión hago

 Connection cn = null;  
 try  
 {
     cn = SQLUtils.getSQLConnection();
     //use connection
 }
 finally 
 {
     if (null != cn)
     {
         try
         {
             cn.close();
         }
         catch (SQLException e)
         {

         }
     }
 }

Está bien para usarlo de esta manera, o me DataSource debe ser un miembro de la bean ?

  @Stateless  
  @WebService  
  public class TestBean  {  
   private @Resource(name=dbName) DataSource m_ds;   
  }  

Lo siento si es una nube pregunta, pero soy bastante nuevo en Java. Gracias de antemano.

OriginalEl autor a1ex07 | 2009-12-16

3 Comentarios

  1. 15

    Aparte de la C-formato de estilo, un par de líneas innecesarias y un poco pobre, manejo de excepciones, usted puede hacerlo.

    Esto es lo que yo haría:

    public final class SQLUtil {
        private static DataSource dataSource;
        //..
    
        static {
            try {
                dataSource = (DataSource) new InitialContext().lookup(name);
            } catch (NamingException e) {
                throw new ExceptionInInitializerError(e);
            }
        }
    
        public static Connection getConnection() throws SQLException {  
            return dataSource.getConnection();             
        }
    }

    Me tiro aquí ExceptionInInitializerError para que la aplicación se detendrá inmediatamente, de modo que usted no necesita a cara «inexplicable», NullPointerException cuando tratando de obtener una conexión.

    +1 para el ExceptionInInitializerError que yo no sabía.
    Sin embargo yo lo haría a favor de la inyección en el grano en sí, porque es más fácil burlarse y a prueba.
    Muchas gracias por tu respuesta.
    Como Pascal señaló, que en realidad no necesitamos todas esas cosas. Sólo un @Resource es suficiente.

    OriginalEl autor BalusC

  2. 10

    En la antigua J2EE mundo, la forma tradicional de gestionar este fue el uso de un ServiceLocator. A continuación, un ejemplo de implementación (no optimizado, el DataSource podría ser caché):

    public class ServiceLocator {
        private Context initalContext;
    
        private static ServiceLocator ourInstance = new ServiceLocator();
    
        public static ServiceLocator getInstance() {
            return ourInstance;
        }
    
        private ServiceLocator() {
            try {
                this.initalContext = new InitialContext();
            } catch (NamingException ex) {
                throw new ServiceLocatorException(...);
            }
        }
    
        public DataSource getDataSource(String dataSourceName) {
            DataSource datasource = null;
    
            try {
                Context ctx = (Context) initalContext.lookup("java:comp/env");
                datasource = (DataSource) ctx.lookup(dataSourceName);
            } catch (NamingException ex) {
                throw new ServiceLocatorException(...);
            }
    
            return datasource;
        }
    }

    Para utilizarlo, sólo tiene que llamar las cosas como esta:

    DataSource ds = ServiceLocator.getInstance().getDataSource("jdbc/mydatabase");

    Pero esto fue antes de la EJB3 y la Inyección de Dependencia de la época. Ahora, cuando el uso de EJB3, si tiene la configuración de su DataSource en su contenedor de EJB, todo lo que tienes que hacer para inyectar automáticamente el DataSource en su Apátridas Bean es escribir (donde mydatabase es el nombre del origen de datos):

    @Resource
    private DataSource mydatabase;

    Utilizar el nombre de atributo si desea explícitamente, además, establecer el nombre:

    @Resource(name="jdbc/mydatabase")
    private DataSource dataSource;

    EJB3 hacer realidad la ServiceLocator patrón obsoleto y que realmente debe preferir la inyección cuando se trabaja con ellos.

    Ah drat, yo sabía que. De hecho, es mucho mejor que algunos de la clase auxiliar. +1.

    OriginalEl autor Pascal Thivent

  3. 0

    Um, no es este un ejemplo de un origen de datos JDBC, no Glassfish Conexión Piscina?

    OriginalEl autor Per Lindberg

Dejar respuesta

Please enter your comment!
Please enter your name here