没有类型为'的合格bean；com.springmvc.dao.UserDAO'；可用：至少需要1个符合autowire候选资格的bean

由于没有“com.springmvc.dao.UserDAO”类型的合格bean可用，我收到一个错误：至少需要1个符合autowire候选条件的bean。对于以下代码，我的基类是“com.springmvc”

我的控制器类是

package com.springmvc.controller;

import java.text.DateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import com.springmvc.dao.UserDAO;
import com.springmvc.dao.UserDAOImpl;
import com.springmvc.type.User;


@Controller
public class HomeController {

    private static final Logger logger = LoggerFactory.getLogger(HomeController.class);

    @Autowired
    private UserDAO usrdao;

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public String home(Locale locale, Model model) {

        logger.info("Welcome home! The client locale is {}.", locale);

        Date date = new Date();
        DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);       
        String formattedDate = dateFormat.format(date);     
        model.addAttribute("Date", formattedDate );     
        return "index";
    }
    /*
    @RequestMapping(value="/login",method = RequestMethod.POST)
    public String welcome(Locale locale,Model model,@ModelAttribute("LoginBean")LoginBean login){

        if(login != null && login.getUserName() != "" && login.getPassword() != ""){

            if(login.getUserName().equals("ajith") && login.getPassword().equals("123")){

                model.addAttribute("msg","Welcome "+login.getUserName());
                return "welcome";   
            }
            else{

                model.addAttribute("error","Invalid Login Details");
                return "index";
            }
        }
        else{

            model.addAttribute("error","Please Enter Login Details");
            return "index";
        }
    }
    */
    @RequestMapping(value="/checkLogin",method = RequestMethod.POST)
    public String CheckUser(Model model,@ModelAttribute("User")User user){

        if(user != null && user.getUserName() != "" && user.getPass() != ""){

            boolean isActive            = usrdao.isActiveUser(user.getUserName(), user.getPass());

            if(isActive){
                List<User> usrLst   = usrdao.ListAllUsers();
                model.addAttribute("message",user.getUserName());
                model.addAttribute("usrLst",usrLst);
                return "home";
            }
            else{
                model.addAttribute("error","Invalid Login Details");
                return "index";
            }               
        }
        return "index";     
    }   
    @RequestMapping(value="/createUser", method = RequestMethod.GET)
    public String RedirectCreateUser(Model model){

        return "createUser";
    }

    public String createUser(Model model, @ModelAttribute User user){       


        usrdao.CreateOrUpdateUser(user);        
        return "";
    }
}

package com.springmvc.controller；
导入java.text.DateFormat；
导入java.util.Date；
导入java.util.List；
导入java.util.Locale；
导入java.util.Map；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.beans.factory.annotation.Qualifier；
导入org.springframework.context.ApplicationContext；
导入org.springframework.context.annotation.ComponentScan；
导入org.springframework.context.support.ClassPathXmlApplicationContext；
导入org.springframework.stereotype.Controller；
导入org.springframework.ui.Model；
导入org.springframework.web.bind.annotation.ModelAttribute；
导入org.springframework.web.bind.annotation.RequestMapping；
导入org.springframework.web.bind.annotation.RequestMethod；
导入org.springframework.web.bind.annotation.RequestParam；
导入com.springmvc.dao.UserDAO；
导入com.springmvc.dao.UserDAOImpl；
导入com.springmvc.type.User；
@控制器
公共类家庭控制器{
私有静态最终记录器Logger=LoggerFactory.getLogger（HomeController.class）；
@自动连线
私有用户dao usrdao；
@RequestMapping（value=“/”，method=RequestMethod.GET）
公共字符串主页（区域设置、模型）{
info（“欢迎回家！客户端语言环境是{}.”，locale）；
日期=新日期（）；
DateFormat DateFormat=DateFormat.getDateTimeInstance（DateFormat.LONG，DateFormat.LONG，locale）；
字符串formattedDate=dateFormat.format（日期）；
model.addAttribute（“日期”，formattedDate）；
返回“索引”；
}
/*
@RequestMapping（value=“/login”，method=RequestMethod.POST）
公共字符串欢迎（区域设置、模型模型、@modeldattribute（“LoginBean”）LoginBean登录）{
if（login！=null&&login.getUserName（）！=“”&&login.getPassword（）！=“”）{
if（login.getUserName（）.equals（“ajith”）和&login.getPassword（）.equals（“123”））{
model.addAttribute（“msg”，“Welcome”+login.getUserName（））；
返回“欢迎”；
}
否则{
model.addAttribute（“错误”，“无效的登录详细信息”）；
返回“索引”；
}
}
否则{
model.addAttribute（“错误”，“请输入登录详细信息”）；
返回“索引”；
}
}
*/
@RequestMapping（value=“/checkLogin”，method=RequestMethod.POST）
公共字符串CheckUser（模型模型，@modeldattribute（“用户”）用户）{
if（user！=null&&user.getUserName（）！=“”&&user.getPass（）！=“”）{
布尔值isActive=usrdao.isactiveeuser（user.getUserName（），user.getPass（））；
如果（isActive）{
List usrLst=usrdao.listalUsers（）；
model.addAttribute（“message”，user.getUserName（））；
addAttribute（“usrLst”，usrLst）；
返回“家”；
}
否则{
model.addAttribute（“错误”，“无效的登录详细信息”）；
返回“索引”；
}               
}
返回“索引”；
}   
@RequestMapping（value=“/createUser”，method=RequestMethod.GET）
公共字符串重定向CreateUser（模型）{
返回“createUser”；
}
公共字符串createUser（模型模型，@ModelAttribute用户）{
usrdao.CreateOrUpdateUser（用户）；
返回“”；
}
}

用户道

package com.springmvc.dao;

import java.util.List;

import com.springmvc.type.User;

public interface UserDAO {

    public void CreateOrUpdateUser(User user);
    public void DeleteUser(int uid);
    public User GetUser(int uid);
    public List<User> ListAllUsers();
    public boolean isActiveUser(String userName,String pass);
}

package com.springmvc.dao；
导入java.util.List；
导入com.springmvc.type.User；
公共接口UserDAO{
public void CreateOrUpdateUser（用户）；
公共用户（int-uid）；
公共用户GetUser（int-uid）；
公共列表列表用户（）；
公共布尔isActiveUser（字符串用户名、字符串传递）；
}

UserDAOImpl

package com.springmvc.dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.sql.DataSource;

import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.stereotype.Repository;

import com.springmvc.type.User;

@Repository("UserDAO")
public class UserDAOImpl implements UserDAO {

    private JdbcTemplate jdbc;  
    /*
    public void setJdbc(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }
    */
    public UserDAOImpl(DataSource DS) {
        jdbc = new JdbcTemplate(DS);
    }

    @Override
    public void CreateOrUpdateUser(User user) {

        if(user.getUid() == 0){
            String query    = "INSERT INTO userdetails(UserName,Name,Pass) VALUES(?,?,?)";
            jdbc.update(query,user.getUserName(),user.getName(),user.getPass());
        }
        else{
            String query    = "UPDATE userdetails SET UserName = ?,Name = ?,Pass = ?,isActive = ? WHERE id = ?";
            jdbc.update(query, user.getUserName(),user.getName(),user.getPass(),user.getIsActive(),user.getUid());
        }
    }

    @Override
    public void DeleteUser(int uid) {

        String query    = "DELETE FROM userdetails WHERE id = ?";
        jdbc.update(query, uid);
    }

    @Override
    public User GetUser(int uid) {

        String query    = "SELECT * FROM userdetails WHERE id = ?";
        return  jdbc.query(query, new ResultSetExtractor<User>() {

            @Override
            public User extractData(ResultSet rs) throws SQLException, DataAccessException {

                if(rs.next()){

                    User user = new User();
                    user.setUid(rs.getInt("id"));
                    user.setUserName(rs.getString("UserName"));
                    user.setName(rs.getString("Name"));
                    user.setIsActive(rs.getInt("isActive"));
                    return user;
                }
                return null;
            }
        });     
    }

    @Override
    public List<User> ListAllUsers() {

        String query        = "SELECT * FROM userdetails";
        List <User> usrLst  = jdbc.query(query, new RowMapper<User>() {

            @Override
            public User mapRow(ResultSet rs, int rowNum) throws SQLException {

                User user   = new User();
                user.setUid(rs.getInt("id"));
                user.setUserName(rs.getString("UserName"));
                user.setName(rs.getString("Name"));
                user.setIsActive(rs.getInt("isActive"));
                return user;
            }
        });
        return usrLst;
    }

    @Override
    public boolean isActiveUser(String userName, String pass) {

        String query    = "SELECT id FROM userdetails WHERE UserName = ? AND Pass = ? AND isActive = 1";    
        SqlRowSet rs    = jdbc.queryForRowSet(query,userName,pass); 
        if(rs.next())
            return true;
        else
            return false;
    }

}

package com.springmvc.dao；
导入java.sql.ResultSet；
导入java.sql.SQLException；
导入java.util.List；
导入javax.sql.DataSource；
导入org.springframework.dao.DataAccessException；
导入org.springframework.jdbc.core.jdbc模板；
导入org.springframework.jdbc.core.ResultSetExtractor；
导入org.springframework.jdbc.core.RowMapper；
导入org.springframework.jdbc.support.rowset.SqlRowSet；
导入org.springframework.stereotype.Repository；
导入com.springmvc.type.User；
@存储库（“UserDAO”）
公共类UserDAOImpl实现UserDAO{
私有jdbc模板jdbc；
/*
公共void setJdbc（jdbc模板jdbc）{
this.jdbc=jdbc；
}
*/
公共UserDAOImpl（数据源DS）{
jdbc=新的JdbcTemplate（DS）；
}
@凌驾
public void CreateOrUpdateUser（用户）{
if（user.getUid（）==0）{
String query=“插入userdetails（用户名、名称、传递）值（？，？）”；
update（查询，user.getUserName（），user.getName（），user.getPass（））；
}
否则{
String query=“UPDATE userdetails SET UserName=？，Name=？，Pass=？，isActive=？其中id=？”；
update（查询，user.getUserName（），user.getName（），user.getPass（），user.getIsActive（），user.getUid（））；
}
}
@凌驾
公共void DeleteUser（int-uid）{
String query=“从userdetails中删除，其中id=？”；
update（查询，uid）；
}
@凌驾
公共用户GetUser（int-uid）{
String query=“从userdetails中选择*，其中id=？”；
返回jdbc.query（query，newresultsetextractor（）{
@凌驾
公共用户extractData（ResultSet rs）抛出SQLException、DataAccessException{
如果（rs.next（））{