principiantes - spring java manual

autoconfiguración de arranque de primavera con plantilla jdbc autocableante problema DataSource

Question

Soy nuevo en Spring y en J2EE en general. Tengo problemas para usar la plantilla JDBC con la autoconfiguración de Spring Boot.

Lo que hice fue tomar el ejemplo del servicio web RESTful proporcionado aquí y decidí ampliarlo para usar el acceso a la base de datos relacional de la plantilla JDBC. Lamentablemente, otro ejemplo proporcionado no puede ser útil porque no se considera la única dificultad que proporciona dataSource del archivo xml beans.

Lo que traté de resolver el problema:

1. Usando la clase DAO Impl como extensión de diferentes implementaciones de Spring.
2. Agregando al archivo de frijoles.
3. Usar diferentes clases de DataSource (por ejemplo, DriverManagerDataSource).
4. Intentando conectar automáticamente solo un atributo simple en una clase diferente (algo menos complejo que la fuente de datos).
5. Al principio acabo de escribir la clase DAO, pero luego pensé que tal vez es posible autocablear el origen de datos solo si implementa una interfaz, lo probó, no ayudó.

Probé todo lo que encontré en Stack o Google. La mayoría de los ejemplos están muy desactualizados o sin respuesta o no tienen nada que ver con la autoconfiguración de Spring Boot, etcétera.

Sigo recibiendo Property ''dataSource'' is required , después de luchar si finalmente logré vincular el archivo application-config.xml con beans, pero no puedo administrar el origen de datos para JDBC.

Estoy desesperado por terminarlo y estoy seriamente bloqueado, sin ideas, estaría encantado si alguien pudiera proporcionar un ejemplo reciente que funcione con Spring Boot Autoconfigurations, beans en XML find, fuente de datos autowired para JDBC.

O al menos algunas ideas, pistas e incluso cómo buscarlo, porque incluso me faltan palabras clave para googlear.

¡Gracias!

Clase de aplicación de primavera.

package ws;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
@Configuration
@ComponentScan
@ImportResource("classpath:spring/application-config.xml")
@EnableAutoConfiguration
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

Clase de servicio web

package ws;
import dao.UserDAOImpl;
import model.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestWS {
@RequestMapping("/greeting")
public User greeting(@RequestParam(value="name", defaultValue="World") String name) {
return new User("ubububu", "661331555", 0);
}
@RequestMapping("/create")
public String initialize() {
UserDAOImpl users = new UserDAOImpl();
users.init();
return "seems ok";
}
}

Interfaz DAO

package dao;
import model.User;
public interface UserDAO {
public void insert(User usr);
public void init();
public User select(int id);
}

Implementación DAO

package dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.stereotype.Repository;
import model.User;
import dao.UserDAO;
@Repository
public class UserDAOImpl implements UserDAO {
private JdbcTemplate jdbcTemplate;
private DriverManagerDataSource dataSource;
@Autowired
public void setDataSource(DriverManagerDataSource dataSource) {
this.dataSource = dataSource;
}
public void insert(User usr) {
String sql = "INSERT INTO USER " +
"(USR_ID, EMAIL, PHONE) VALUES (?, ?, ?)";
this.jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.execute(sql);
}
public void init() {
String sql = "CREATE TABLE USER (USR_ID INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,EMAIL VARCHAR(30) NOT NULL,PHONE VARCHAR(15) NOT NULL)";
this.jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.execute(sql);
}
}

Modelo de datos

package model;
public class User {
private String email;
private String phone;
private int id;
public User(String email, String phone, int id) {
this.email = email;
this.phone = phone;
this.id = id;
}
public int getUsrId(){
return this.id;
}
public String getUsrEmail() {
return this.email;
}
public String getUsrPhone() {
return this.phone;
}
}

Archivo bean de configuración

<?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.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<import resource="Spring-User.xml" />-->
<context:component-scan base-package="ws"/>
<bean id="ds"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="org.springframework.jdbc.core.JdbcTemplate" />
<property name="url" value="jdbc:mysql://localhost/:3306/databasename" />
<property name="username" value="root" />
<property name="password" value="password" />
</bean>
<bean id="UserDAOprovider" class="dao.UserDAOImpl">
<property name="dataSource" ref="ds" />
</bean>
</beans>

Mensaje de error:

ERROR [dispatcherServlet] - Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.IllegalArgumentException: Property ''dataSource'' is required] with root cause
java.lang.IllegalArgumentException: Property ''dataSource'' is required
at org.springframework.jdbc.support.JdbcAccessor.afterPropertiesSet(JdbcAccessor.java:135) ~[spring-jdbc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.jdbc.core.JdbcTemplate.<init>(JdbcTemplate.java:169) ~[spring-jdbc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at dao.UserDAOImpl.init(UserDAOImpl.java:66) ~[demo3-0.0.1-SNAPSHOT.jar!/:na]
at ws.TestWS.initialize(TestWS.java:30) ~[demo3-0.0.1-SNAPSHOT.jar!/:na]
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.6.0_33]
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) ~[na:1.6.0_33]
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.6.0_33]
at java.lang.reflect.Method.invoke(Method.java:622) ~[na:1.6.0_33]
at org.springframework.web.method.support.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:215) ~[spring-web-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:132) ~[spring-web-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:104) ~[spring-webmvc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandleMethod(RequestMappingHandlerAdapter.java:749) ~[spring-webmvc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:689) ~[spring-webmvc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:83) ~[spring-webmvc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:938) ~[spring-webmvc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:870) ~[spring-webmvc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:961) ~[spring-webmvc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:852) ~[spring-webmvc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at javax.servlet.http.HttpServlet.service(HttpServlet.java:620) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:837) ~[spring-webmvc-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at javax.servlet.http.HttpServlet.service(HttpServlet.java:727) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:303) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.springframework.web.filter.HiddenHttpMethodFilter.doFilterInternal(HiddenHttpMethodFilter.java:77) ~[spring-web-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107) ~[spring-web-4.0.8.RELEASE.jar!/:4.0.8.RELEASE]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:220) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:122) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:503) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:170) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:103) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:116) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:421) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1070) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:611) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1736) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.run(NioEndpoint.java:1695) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1146) ~[na:1.6.0_33]
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615) ~[na:1.6.0_33]
at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61) ~[tomcat-embed-core-7.0.57.jar!/:7.0.57]
at java.lang.Thread.run(Thread.java:701) ~[na:1.6.0_33]

Answer 1

La forma más sencilla de configurar un DataSource en Spring Boot es crear un archivo application.properties en src / main / resources con el siguiente contenido (puede necesitar actualizarlo con la URL, el nombre de usuario y la contraseña correctos):

spring.datasource.url=jdbc:mysql://localhost/:3306/databasename
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

Spring Boot creará automáticamente la clase DataSource para usted e inyectará a otros beans. Como resultado de eso, ya no necesitará el archivo de configuración xml y puede deshacerse de esta línea en la clase de aplicación:

@ImportResource("classpath:spring/application-config.xml")

Además, en UserDAOImpl Spring puede autoconectarse el objeto JdbcTemplate utilizando el bean DataSource ( http://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-sql.html#boot-features- using-jdbc-template ) por lo que no necesita crear uno cada vez que se invoca el método insert ().

En cuanto al método init () en UserDAOImpl, puedes crear un archivo schema.sql en src / main / resources y mover la declaración CREATE TABLE allí (para más detalles ver http://docs.spring.io/spring-boot/ docs / 1.2.0.RELEASE / reference / htmlsingle / # howto-intialize-a-database-using-spring-jdbc )

Vea este ejemplo para más información: http://xantorohara.blogspot.ca/2013/11/spring-boot-jdbc-sample.html