No qualifying bean of type [XXX.XXXX.XXXXX] foun

[org.springframework.context.support.GenericApplicationContext] - Refreshing org.springframework.context.support.GenericApplicationContext@6982bec3: startup date [Wed Jun 28 13:39:18 CST 2017]; root of context hierarchy
[org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor] - JSR-330 'javax.inject.Inject' annotation found and supported for autowiring
[org.springframework.test.context.TestContextManager] - Caught exception while allowing TestExecutionListener [org.springframework.test.context.support.DependencyInjectionTestExecutionListener@6ff1ac71] to prepare test instance [com.yunwei.mybatis.TestMybatis@63706821]
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'com.yunwei.mybatis.TestMybatis': Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [com.yunwei.user.service.IUserService] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@javax.annotation.Resource(shareable=true, mappedName=, description=, name=, type=class java.lang.Object, lookup=, authenticationType=CONTAINER)}
at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessPropertyValues(CommonAnnotationBeanPostProcessor.java:307)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1185)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireBeanProperties(AbstractAutowireCapableBeanFactory.java:384)
at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.injectDependencies(DependencyInjectionTestExecutionListener.java:110)
at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.prepareTestInstance(DependencyInjectionTestExecutionListener.java:75)
at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:319)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTest(SpringJUnit4ClassRunner.java:212)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner$1.runReflectiveCall(SpringJUnit4ClassRunner.java:289)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.methodBlock(SpringJUnit4ClassRunner.java:291)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:232)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:89)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:238)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:63)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:236)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:53)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:229)
at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:71)
at org.junit.runners.ParentRunner.run(ParentRunner.java:309)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:175)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [com.yunwei.user.service.IUserService] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@javax.annotation.Resource(shareable=true, mappedName=, description=, name=, type=class java.lang.Object, lookup=, authenticationType=CONTAINER)}
at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:1100)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:960)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:855)
at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.autowireResource(CommonAnnotationBeanPostProcessor.java:441)
at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.java:419)
at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor$ResourceElement.getResourceToInject(CommonAnnotationBeanPostProcessor.java:544)
at org.springframework.beans.factory.annotation.InjectionMetadata$InjectedElement.inject(InjectionMetadata.java:155)
at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:87)
at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessPropertyValues(CommonAnnotationBeanPostProcessor.java:304)
... 26 more
[org.springframework.context.support.GenericApplicationContext] - Closing org.springframework.context.support.GenericApplicationContext@6982bec3: startup date [Wed Jun 28 13:39:18 CST 2017]; root of context hierarchy

package com.yunwei.user.service.impl;

import java.util.List;

import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UnknownAccountException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.yunwei.shiro.ShiroKit;
import com.yunwei.user.dao.IRoleDao;
import com.yunwei.user.dao.IUserDao;
import com.yunwei.user.pojo.Role;
import com.yunwei.user.pojo.User;
import com.yunwei.user.pojo.Resource;
import com.yunwei.user.service.IUserService;

@Service
public class UserServiceImpl implements IUserService {
private static final Logger logger = LoggerFactory
.getLogger(UserServiceImpl.class);
@Autowired
private IUserDao userDao;
@Autowired
private IRoleDao roleDao;

/**
 * 返回新插入用户数据的主键
 * 
 * @param user
 * @return
 */
@Override
public Integer add(User user) {
    // 使用用户名作为盐值，MD5 算法加密
    user.setPassword(ShiroKit.md5(user.getPassword(), user.getUsername()));
    userDao.add(user);
    Integer userID = user.getId();
    return userID;
}

/**
 * 为单个用户设置多个角色
 * 
 * @param user
 * @param rids
 */
@Override
public void add(User user, List<Integer> rids) {
    Integer userId = this.add(user);
    roleDao.addUserRoles(userId, rids);
}

/**
 * 根据 user_id 删除用户数据
 * 
 * @param id
 */
@Override
public void delete(int id) {
    userDao.delete(id);
}

/**
 * 更新用户数据 1、更新用户基本信息 2、更新用户所属角色 （1）先删除所有的角色 （2）再添加绑定的角色
 * 
 * @param user
 * @param rids
 */
@Override
public void update(User user, List<Integer> rids) {
    Integer userId = user.getId();
    roleDao.deleteUserRoles(userId);
    roleDao.addUserRoles(userId, rids);
    this.update(user);
}

/**
 * 更新单个用户信息
 * 
 * @param user
 * @return
 */
@Override
public Integer update(User user) {
    String password = user.getPassword();
    if (password != null) {
        user.setPassword(ShiroKit.md5(user.getPassword(),
                user.getUsername()));
    }
    return userDao.update(user);
}

/**
 * 根据主键 id 加载用户对象
 * 
 * @param id
 * @return
 */
@Override
public User load(int id) {
    return userDao.load(id);
}

/**
 * 根据用户名加载用户对象（用于登录使用）
 * 
 * @param username
 * @return
 */
@Override
public User loadByUsername(String username) {
    return userDao.loadByUserName(username);
}

/**
 * 登录逻辑 1、先根据用户名查询用户对象 2、如果有用户对象，则继续匹配密码 如果没有用户对象，则抛出异常
 * 
 * @param username
 * @param password
 * @return
 */
@SuppressWarnings("unused")
@Override
public User login(String username, String password) {
    User user = userDao.loadByUserName(username);
    if (user == null) {
        // 抛出对象不存在异常
        logger.debug("用户名不存在");
        throw new UnknownAccountException("用户名和密码不匹配");
    } else if (false) {
        // !user.getPassword().equals(password)
        logger.debug("密码错误");
        // 抛出密码不匹配异常
        throw new IncorrectCredentialsException("用户名和密码不匹配");
    } else if (user.getStatus() == 0) {
        throw new LockedAccountException("用户已经被锁定，请联系管理员启动");
    }
    return user;
}

/**
 * 查询所有的用户对象列表
 * 
 * @return
 */
@Override
public List<User> list() {
    return userDao.listUser();
}

/**
 * 根据角色 id 查询是这个角色的所有用户
 * 
 * @param id
 * @return
 */
@Override
public List<User> listByRole(int id) {
    return userDao.listByRole(id);
}

/**
 * 查询指定用户所指定的角色字符串列表
 * 
 * @param uid
 * @return
 */
@Override
public List<Resource> listAllResource(int uid) {
    return userDao.listAllResources(uid);
}

/**
 * 查询指定用户所绑定的角色列表
 * 
 * @param uid
 * @return
 */
@Override
public List<String> listRoleSnByUser(int uid) {
    return userDao.listRoleSnByUser(uid);
}

/**
 * 查询指定用户所绑定的角色列表
 * 
 * @param uid
 * @return
 */
@Override
public List<Role> listUserRole(int uid) {
    return userDao.listUserRole(uid);
}

}

package com.yunwei.user.service;

import java.util.List;

import com.yunwei.user.pojo.Resource;
import com.yunwei.user.pojo.Role;
import com.yunwei.user.pojo.User;
public interface IUserService {
/**
* 添加单个用户
*
* @param user
*/
public Integer add(User user);

/**
 * 批量添加用户角色关联表数据
 * 
 * @param user
 * @param rids
 */
public void add(User user, List<Integer> rids);

/**
 * 根据 user_id 删除用户数据
 * 
 * @param id
 */
public void delete(int id);

/**
 * （2）再添加绑定的角色
 * 
 * @param user
 * @param rids
 */
public void update(User user, List<Integer> rids);

/**
 * 更新单个用户信息
 * 
 * @param user
 * @return
 */
public Integer update(User user);

/**
 * 根据主键 id 加载用户对象
 * 
 * @param id
 * @return
 */
public User load(int id);

/**
 * 根据用户名加载用户对象（用于登录使用）
 * 
 * @param username
 * @return
 */
public User loadByUsername(String username);

/**
 * 登录逻辑 1、先根据用户名查询用户对象 2、如果有用户对象，则继续匹配密码 如果没有用户对象，则抛出异常
 * 
 * @param username
 * @param password
 * @return
 */
public User login(String username, String password);

/**
 * 查询所有的用户对象列表
 * 
 * @return
 */
public List<User> list();

/**
 * 根据角色 id 查询是这个角色的所有用户
 * 
 * @param id
 * @return
 */
public List<User> listByRole(int id);

/**
 * 查询指定用户 id 所拥有的权限
 * 
 * @param uid
 * @return
 */
public List<Resource> listAllResource(int uid);

/**
 * 查询指定用户所指定的角色字符串列表
 * 
 * @param uid
 * @return
 */
public List<String> listRoleSnByUser(int uid);

/**
 * 查询指定用户所绑定的角色列表
 * 
 * @param uid
 * @return
 */
public List<Role> listUserRole(int uid);

}

package com.yunwei.user.dao;

import java.util.List;

import org.springframework.stereotype.Component;

import com.yunwei.user.pojo.Resource;
import com.yunwei.user.pojo.Role;
import com.yunwei.user.pojo.User;
@Component("UserMapper")
public interface IUserDao {
public Integer add(User user);

public Integer update(User user);

public Integer delete(Integer id);

public User load(Integer id);

public List<User> listUser();

public User loadByUserName(String username);

/**
 * 根据角色 id 查询所有是该角色的用户列表
 * 
 * @param rid
 * @return
 */
public List<User> listByRole(Integer rid);

public List<Resource> listAllResources(Integer uid);

public List<String> listRoleSnByUser(Integer uid);

public List<Role> listUserRole(Integer uid);

}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >









id, username, password, nickname,status


SELECT
id,
username,
password,
nickname,
status
FROM
t_user
WHERE
id = #{id}


SELECT
id,
username,
password,
nickname,
status
FROM
t_user

parameterType="java.lang.String">
SELECT
id,
username,
password,
nickname,
status
FROM
t_user
WHERE
username = #{username}


SELECT
tu.id,
tu.username,
tu.password,
tu.nickname,
tu.status
FROM
t_user tu
LEFT JOIN t_user_role tur ON tu.id = tur.user_id
LEFT JOIN t_role tr ON
tur.role_id = tr.id
WHERE tr.id =#{rid}

<!-- 根据用户 id 查询这个用户拥有的所有资源（这里的资源就代表权限） -->
parameterType="java.lang.Integer">
SELECT tr.id,tr.name,tr.permission,tr.url
FROM t_resource
tr
LEFT JOIN t_role_resource trr ON tr.id = trr.resource_id
LEFT JOIN
t_user_role tur ON trr.role_id = tur.role_id
WHERE tur.user_id = #{uid}

<!-- 根据用户 id 查询用户所具有的角色字符串表示 -->
parameterType="java.lang.Integer">
SELECT
tr.sn
FROM t_role tr
LEFT JOIN t_user_role tur ON tr.id = tur.role_id
LEFT JOIN t_user tu ON tur.user_id = tu.id
WHERE tu.id = #{uid}

<!-- 根据用户 id 查询用户所具有的角色对象表示 -->

SELECT
tr.id,
tr.name,
tr.sn
FROM t_role tr
LEFT JOIN t_user_role tur ON tr.id = tur.role_id
LEFT JOIN t_user tu ON tur.user_id = tu.id
WHERE tu.id = #{uid}


DELETE FROM t_user
where id =
#{id}


insert into t_user
(username,password,nickname,status)
values
(#{username},#{password},#{nickname},#{status})


UPDATE t_user


username = #{username},


password = #{password},


nickname = #{nickname},


status = #{status}


WHERE
id = #{id}

<?xml version="1.0" encoding="UTF-8"?>
xmlns:util="http://www.springframework.org/schema/util" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-4.0.xsd">
<!-- 自动扫描 -->

<!-- 引入配置文件 -->
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">


<!-- 这里支持多种寻址方式：classpath和file -->
classpath:jdbc.properties
<!-- 推荐使用file的方式引入，这样可以将配置和代码分离 -->
classpath:dust.properties



<!-- jdbc参数配置 -->
destroy-method="close">




<!-- 初始化连接大小 -->

<!-- 连接池最大数量 -->

<!-- 连接池最大空闲 -->

<!-- 连接池最小空闲 -->

<!-- 获取连接最大等待时间 -->


<!--重试发送数据类 参数配置 -->








<!-- 数据发送类参数配置 -->
init-method="initMethod">






<!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->


<!-- 自动扫描mapping.xml文件 -->


<!-- DAO接口所在包名，Spring会自动查找其下的类 -->




<!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

package com.yunwei.mybatis;

import javax.annotation.Resource;

import org.apache.log4j.Logger;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.yunwei.user.pojo.User;
import com.yunwei.user.service.IUserService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:*/spring-mybatis.xml"})
public class TestMybatis {
private static Logger logger = Logger.getLogger(TestMybatis.class);
@Resource
private IUserService userService;

@Test
public void test1() throws Exception {
    User user = new User();
    user.setUsername("zhouguang");
    user.setPassword("666666");
    user.setNickname("周光1");
    user.setStatus(1);
    userService.add(user);
    logger.debug("返回自增长的主键：" + user.getId());
}

}