La propriété "source de données" n'est pas nécessaire d'Erreur en java (Spring)

Je devine que vous êtes complètement nouveau pour Java, JEE, Spring et JDBC. Comme je l'ai dit dans mon commentaire, il est difficile de répondre à votre question, si ce que vous faites là est incorrect dans sa base. Je vais essayer d'aller à travers quelques thèmes et j'espère aussi cerner le point d'où votre question est.

Printemps app structure

Vous devez assurez-vous de bien structurer votre projet:

• src
  • main
    • java - répertoire pour les sources Java
      • in/mmali/springtest/controller/IndexController.java - Votre contrôleur de classe
    • resources - répertoire pour les non-Java (re)sources
    • webapp de la racine de l'application web de ressources
      • WEB-INF/web.xml - JEE web de configuration de l'application
      • WEB-INF/spring-servlet.xml - contexte de l'application de configuration pour dispatcher servlet
• pom.xml - Maven config (dans le cas où vous utilisez Maven)

Je dirais que c'est une structure commune pour les projets Java, la plupart du temps "normalisée" par Maven.

Corriger JEE config

Vous avez besoin d'avoir une web.xml configuration:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> 

    <servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

C'est une configuration de base (sans la racine de contexte), qui permettra d'utiliser votre spring-servlet.xml que le Printemps contexte de configuration.

Correcte configuration Spring

Vous avez besoin d'avoir corriger le Printemps contexte de configuration:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    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
                        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <mvc:annotation-driven />
    <mvc:resources location="/resources/" mapping="/resources/**" />

    <!-- With ROOT context we would restrict component scan on controllers here -->
    <context:component-scan base-package="in.mmali.springtest" />

    <!-- Data source configuration would normally go inside ROOT context. -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/cjbranchdb" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
        <property name="dataSource" ref="dataSource" />
    </bean> 
</beans>

Cela va charger toutes les classes annotées avec @Component (et de ses compagnons @Controller, @Service, @Repository) comme les haricots. Bean dans un contexte de Printemps de l'application est un objet géré par le Printemps -> c'est à dire un objet qui est instanciée par la source elle-même. Lorsque vous voulez travailler avec un Printemps bean, vous devez avoir injecté (par exemple en utilisant @Autowired annotation) ou vous avez besoin de sortir de ApplicationContext#getBean manuellement.

De travail avec JDBC

De travail avec JDBC est pénible avec tous les fermer ressources et vérifié les exceptions. C'est pourquoi le Printemps-JDBC projet enveloppements API JDBC de sorte que vous n'avez pas à l'utiliser.

Pour mettre en valeur la façon dont vous devriez travailler avec JDBC et aussi comment laisser de Printemps injecter des dépendances, voici un contrôleur simple:

@Controller //Will be detected by <context:component-scan>
@RequestMapping //Will be detected by <mvc:annotation-driven> (more specifically by one of its component - RequestMappingHandlerMapping)
public class IndexController {

    @Autowired //Spring will inject JdbcTemplate here
    private JdbcOperations jdbcOperations; 

    @RequestMapping //This method should be called for requests to "/" 
    @ResponseBody //Returned string will be returned to client... normally you would register view resolver and just return name of a JSP to render
    public String renderIndex() {
        //You don't need to worry about JDBC's DataSource, Connection, ResultSet, ... just use JdbcTemplate
        long rowCount = jdbcOperations.queryForLong("SELECT COUNT(*) FROM my_test_table;");
        return "Number of rows in database is: " + String.valueOf(rowCount);
    } 

}

Noter que, dans une application réelle, vous ne permettrait pas de contrôleur de travailler avec votre source de données directement, mais plutôt par le service et la couche de données.

Prochaines étapes

• Commencer à utiliser la journalisation système et de ne jamais utiliser System.out.println dans une application web à nouveau ;). Je suggère slf4j avec sa liaison simple pour commencer (plus tard, vous pouvez le configurer pour utiliser logback ou log4j).
• Configurer votre application pour utiliser les transactions. L'utilisation de Ressort de la gestion des transactions (<tx:annotation-driven/> avec @Transactional). Il pourrait regarder comme de la magie au premier abord, mais lorsque vous découvrez quelque chose sur les AOP et les classes proxy, vous serez alors commencer à vraiment appretiating les principes de la des travaux du Printemps.
• De diviser votre application logique de la couche de service et de données (DAO) de la couche.
• Vérifier Printemps de l'exemple d'application (http://docs.spring.io/docs/petclinic.html) et l'application de référence (https://github.com/spring-projects/greenhouse).

Fonction du nom de fichier, je suppose que vous êtes la construction d'une application basée sur le web.

Pour la capture de l'erreur, veuillez utiliser un bon de journalisation au lieu de Système.out.println.

En fonction de l'erreur, de la source de données semble nulle. Veuillez vérifier si votre web.xml a défini la servlet fichier xml, comme

<servlet>
    <servlet-name>spring_app</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
     <param-name>contextConfigLocation</param-name>
     <param-value>/WEB-INF/spring-servlet.xml</param-value>
  </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

En outre, DriverManagerDataSource est assez bon pour tests uniquement. Pour une utilisation en production, veuillez tenir compte de Apache Jakarta Commons DBCP ou C3P0. Voir les détails à l'officiel page web.

Depuis votre fichier XML a mentionné

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

le fichier XML doit consister en une servlet section d'appel de l'objet id=JdbcTemplate. Par exemple,

<bean id="MyServlet" class="com.my.MyServlet"> 
    <property name="jdbcTemplate"><ref bean="JdbcTemplate"/></property> 
</bean>