java - mkyong - namedparameterjdbctemplate

utilizando Spring JdbcTemplate-inyectando datasource vs jdbcTemplate

Question

Según la documentation Spring, los pasos para utilizar Spring JdbcTemplate son los siguientes:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-3.0.xsd">

        <!-- Scans within the base package of the application for @Components to configure as beans -->
        <context:component-scan base-package="org.springframework.docs.test" />

        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
            <property name="driverClassName" value="${jdbc.driverClassName}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>

        <context:property-placeholder location="jdbc.properties"/>

    </beans>

Y entonces,

    @Repository
    public class JdbcCorporateEventDao implements CorporateEventDao {

        private JdbcTemplate jdbcTemplate;

        @Autowired
        public void setDataSource(DataSource dataSource) {
            this.jdbcTemplate = new JdbcTemplate(dataSource);
        }

        // JDBC-backed implementations of the methods on the CorporateEventDao follow...
    }

Básicamente, JdbcTemplate se crea dentro de la clase Component usando el setter para el origen de datos.

¿Hay algo malo en hacerlo de esta manera para que exista exactamente UNA instancia de jdbcTemplate en la aplicación?

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
    p:dataSource-ref="dataSource" 
/>

Y luego inyectando la plantilla jdbc directamente en el Componente

@Repository
public class JdbcCorporateEventDao implements CorporateEventDao {
    @Resource("jdbcTemplate")
    private JdbcTemplate jdbcTemplate;


    // JDBC-backed implementations of the methods on the CorporateEventDao follow...
}

¿Hay alguna razón por la cual jdbcTemplate no deba ser inyectado directamente en la clase de componente?

SGB

Answer 1

En el spring-context.xml agregue lo siguiente y

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
</bean>

y directamente puedes usar jdbcTemplate al autocablear como

  @Autowired JdbcTemplate jdbcTemplate;

ejemplo:

this.jdbcTemplate.query("select * from ******",new RowMapper());

Answer 2

Puedes hacer lo que quieras. El javadoc de JdbcTemplate incluso lo dice claramente:

Puede usarse dentro de una implementación de servicio a través de una instanciación directa con una referencia de DataSource, o puede prepararse en un contexto de aplicación y entregarse a los servicios como referencia de bean.

Answer 3

También puedes hacerlo como

@Configuration
@Import({PersistenceConfig.class})
@ComponentScan(basePackageClasses = { 
    ServiceMarker.class,
    RepositoryMarker.class }
)
public class AppConfig {

    /**
     * To resolve ${} in @Values, you must register a static PropertySourcesPlaceholderConfigurer in either XML or 
     * annotation configuration file.
     */
    @Bean
    public static PropertySourcesPlaceholderConfigurer propertyConfigInDev() {
        return new PropertySourcesPlaceholderConfigurer();
    }
}

PersistenceConfig

@Configuration
@PropertySource(value = { "classpath:database/jdbc.properties" })
@EnableTransactionManagement
public class PersistenceConfig {

    @Autowired
    private Environment env;

 /**
  * The @Bean annotation is used to declare a Spring bean and the DI requirements. The @Bean annotation is equivalent to
 *  the <bean> tag, the method name is equivalent to the id attribute within the <bean> tag.
  * 
  * <bean id="mySqlDataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close" 
        p:driverClassName="${jdbc.mysql.driverClassName}" 
        p:url="${jdbc.mysql.url}"   
        p:username="${jdbc.mysql.username}" 
        p:password="${jdbc.mysql.password}" />
  * 
  * @return
  */
     @Bean(destroyMethod = "close")
     public DataSource mySqlDataSource() {
         BasicDataSource dataSource = new BasicDataSource();
         dataSource.setDriverClassName(env.getProperty("jdbc.mysql.driverClassName"));
         dataSource.setUrl(env.getProperty("jdbc.mysql.url"));
         dataSource.setUsername(env.getProperty("jdbc.mysql.username"));
         dataSource.setPassword(env.getProperty("jdbc.mysql.password"));
         return dataSource;
     }

     @Bean(destroyMethod = "close")
     public DataSource ls360DataSource() {
         BasicDataSource dataSource = new BasicDataSource();
         dataSource.setDriverClassName(env.getProperty("jdbc.ls360.driverClassName"));
         dataSource.setUrl(env.getProperty("jdbc.ls360.url"));
         dataSource.setUsername(env.getProperty("jdbc.ls360.username"));
         dataSource.setPassword(env.getProperty("jdbc.ls360.password"));
         return dataSource;
     } 
}

MySqlDaoImpl

@Repository
public class MySqlDaoImpl implements MySqlDao{

    private static final Logger logger = LogManager.getLogger();

    @Inject
    private DataSource mySqlDataSource;
    private JdbcTemplate mySqlJdbcTemplate;

    @PostConstruct
    public void afterPropertiesSet() throws Exception {
        if (mySqlDataSource == null) {
            throw new BeanCreationException("Must set mySqlDataSource on " + this.getClass().getName());
        }
        this.mySqlJdbcTemplate = new JdbcTemplate(mySqlDataSource);
    }

    @Override
    public void callStoredProcedure(String storedProcedureName, Map<String, Object> inParamMap) throws Exception {

        SimpleJdbcCall simpleJdbcCall = new SimpleJdbcCall(mySqlJdbcTemplate).withProcedureName(storedProcedureName);
        SqlParameterSource in = new MapSqlParameterSource(inParamMap);

        logger.info("Calling stored Procedure: " + storedProcedureName);
        Map<String, Object> simpleJdbcCallResult = simpleJdbcCall.execute(in);
        logger.info("Stored Procedure Result: " + simpleJdbcCallResult);
    }
}

Principal

public static void main(String[] args ) {
    try (GenericApplicationContext springContext = new AnnotationConfigApplicationContext(AppConfig.class)) {
        MySQLDao mySqlDao = springContext.getBean(MySQLDaoImpl.class);
        try {
            Map<String, Object> inParamMap = new HashMap<String, Object>();
            inParamMap.put("iCourseId", 1);
            mySqlCourseRenewalDao.callStoredProcedure("usp_processCourseRenewal", inParamMap);
        } catch (Exception e) {
            logger.error("Exception occurs", e);
        }
    } catch (Exception e) {
        logger.error("Exception occurs in loading Spring context: ", e);
    }
}

Gracias