Spring boot Jhipster Cassandra项目未启动

我创建了一个新的jhipster项目，后端为cassandra， 但是，当使用./mvnv启动应用程序时，我遇到错误，应用程序无法启动

错误

[错误]无法在project castrol上执行目标org.springframework.boot:spring boot maven plugin:1.3.5。发布：运行（默认cli）：运行时发生异常。null:InvocationTargetException:创建名为“userService”的bean时出错：自动连线依赖项的注入失败；嵌套异常为org.springframework.beans.factory.BeanCreationException:无法自动连接字段：private org.springframework.security.crypto.PasswordEncoder.com.kpit.castrol.service.UserService.PasswordEncoder；嵌套异常为org.springframework.beans.factory.BeanCreationException:创建名为“securityConfiguration”的bean时出错：自动连线依赖项的注入失败；嵌套异常为org.springframework.beans.factory.BeanCreationException:无法自动连接字段：private org.springframework.security.core.userdetails.userdetails服务com.kpit.castrol.config.SecurityConfiguration.userdetails服务；嵌套异常为org.springframework.beans.factory.BeanCreationException:创建名为“userDetailsService”的bean时出错：自动连线依赖项的注入失败；嵌套异常为org.springframework.beans.factory.BeanCreationException:无法自动关联字段：private com.kpit.castrol.repository.UserRepository com.kpit.castrol.security.UserDetailsService.UserRepository；嵌套异常为org.springframework.beans.factory.BeanCreationException:创建名为“userRepository”的bean时出错：调用init方法失败；嵌套异常为com.datastax.driver.core.exceptions.InvalidQueryException:unconfigured table user->[帮助1]

我是否需要在cassandra中创建用户表

例外情况：

2016-07-13 16:03:51.852错误15114---[ost-startStop-1]o.a.c.c.c.[Tomcat].[localhost].[/]：启动筛选器springSecurityFilterChain时出现异常

org.springframework.beans.factory.BeanCreationException:创建名为“org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration”的bean时出错：自动关联依赖项的注入失败；嵌套异常为org.springframework.beans.factory.BeanCreationException:无法自动连线方法：public void org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration.SetFilterChainProxy SecurityConfigure（org.springframework.security.config.annotation.ObjectPostProcessor，java.util.List）抛出java.lang.Exception；嵌套异常为org.springframework.beans.factory.BeanExpressionException:表达式解析失败；嵌套异常为org.springframework.beans.factory.BeanCreationException:创建名为“securityConfiguration”的bean时出错：自动连线依赖项的注入失败；嵌套异常为org.springframework.beans.factory.BeanCreationException:无法自动连接字段：private org.springframework.security.core.userdetails.userdetails服务com.kpit.castrol.config.SecurityConfiguration.userdetails服务；嵌套异常为org.springframework.beans.factory.BeanCreationException:创建名为“userDetailsService”的bean时出错：自动连线依赖项的注入失败；嵌套异常为org.springframework.beans.factory.BeanCreationException:无法自动关联字段：private com.kpit.castrol.repository.UserRepository com.kpit.castrol.security.UserDetailsService.UserRepository；嵌套异常为org.springframework.beans.factory.BeanCreationException:创建名为“userRepository”的bean时出错：调用init方法失败；嵌套异常为com.datastax.driver.core.exceptions.InvalidQueryException:未配置的表用户 位于org.springframework.beans.factory.annotation.AutoWiredNotationBeanPostProcessor.postProcessPropertyValues（AutoWiredNotationBeanPostProcessor.java:334） 位于org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean（AbstractAutowireCapableBeanFactory.java:1214） 位于org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean（AbstractAutowireCapableBeanFactory.java:543） 位于org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean（AbstractAutowireCapableBeanFactory.java:482） 位于org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject（AbstractBeanFactory.java:306） 位于org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton（DefaultSingletonBeanRegistry.java:230） 位于org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean（AbstractBeanFactory.java:302） 位于org.springframework.beans.factory.support.AbstractBeanFactory.getBean（AbstractBeanFactory.java:197） 位于org.springframework.beans.factory.support.ConstructorResolver.InstanceUsingFactoryMethod（ConstructorResolver.java:368） 位于org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.InstanceUsingFactoryMethod（AbstractAutowireCapableBeanFactory.java:1123） 位于org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance（AbstractAutowireCapableBeanFactory.java:1018） 位于org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean（AbstractAutowireCapableBeanFactory.java:510） 位于org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean（AbstractAutowireCapableBeanFactory.java:482） 位于org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject（AbstractBeanFactory.java:306） 位于org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton（DefaultSingletonBeanRegistry.java:230） 位于org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean（AbstractBeanFactory.java:302） 位于org.springframework.beans.factory.support.AbstractBeanFact

enter code here


/**
 * Cassandra repository for the User entity.
 */
@Repository
public class UserRepository {

    @Inject
    private Session session;

    private Mapper<User> mapper;

    private PreparedStatement findAllStmt;

    private PreparedStatement findOneByActivationKeyStmt;

    private PreparedStatement findOneByResetKeyStmt;

    private PreparedStatement insertByActivationKeyStmt;

    private PreparedStatement insertByResetKeyStmt;

    private PreparedStatement deleteByActivationKeyStmt;

    private PreparedStatement deleteByResetKeyStmt;

    private PreparedStatement findOneByLoginStmt;

    private PreparedStatement insertByLoginStmt;

    private PreparedStatement deleteByLoginStmt;

    private PreparedStatement findOneByEmailStmt;

    private PreparedStatement insertByEmailStmt;

    private PreparedStatement deleteByEmailStmt;

    @PostConstruct
    public void init() {
        mapper = new MappingManager(session).mapper(User.class);

        findAllStmt = session.prepare("SELECT * FROM user");

        findOneByActivationKeyStmt = session.prepare(
            "SELECT id " +
            "FROM user_by_activation_key " +
            "WHERE activation_key = :activation_key");

        findOneByResetKeyStmt = session.prepare(
            "SELECT id " +
            "FROM user_by_reset_key " +
            "WHERE reset_key = :reset_key");

        insertByActivationKeyStmt = session.prepare(
            "INSERT INTO user_by_activation_key (activation_key, id) " +
            "VALUES (:activation_key, :id)");

        insertByResetKeyStmt = session.prepare(
            "INSERT INTO user_by_reset_key (reset_key, id) " +
            "VALUES (:reset_key, :id)");

        deleteByActivationKeyStmt = session.prepare(
            "DELETE FROM user_by_activation_key " +
            "WHERE activation_key = :activation_key");

        deleteByResetKeyStmt = session.prepare(
            "DELETE FROM user_by_reset_key " +
            "WHERE reset_key = :reset_key");

        findOneByLoginStmt = session.prepare(
            "SELECT id " +
            "FROM user_by_login " +
            "WHERE login = :login");

        insertByLoginStmt = session.prepare(
            "INSERT INTO user_by_login (login, id) " +
                "VALUES (:login, :id)");

        deleteByLoginStmt = session.prepare(
            "DELETE FROM user_by_login " +
                "WHERE login = :login");

        findOneByEmailStmt = session.prepare(
            "SELECT id " +
            "FROM user_by_email " +
            "WHERE email     = :email");

        insertByEmailStmt = session.prepare(
            "INSERT INTO user_by_email (email, id) " +
                "VALUES (:email, :id)");

        deleteByEmailStmt = session.prepare(
            "DELETE FROM user_by_email " +
                "WHERE email = :email");
    }

    public User findOne(String id) {
        return mapper.get(id);
    }

    public Optional<User> findOneById(String id) {
        return Optional.of(findOne(id));
    }

    public Optional<User> findOneByActivationKey(String activationKey) {
        BoundStatement stmt = findOneByActivationKeyStmt.bind();
        stmt.setString("activation_key", activationKey);
        return findOneFromIndex(stmt);
    }

    public Optional<User> findOneByResetKey(String resetKey) {
        BoundStatement stmt = findOneByResetKeyStmt.bind();
        stmt.setString("reset_key", resetKey);
        return findOneFromIndex(stmt);
    }

    public Optional<User> findOneByEmail(String email) {
        BoundStatement stmt = findOneByEmailStmt.bind();
        stmt.setString("email", email);
        return findOneFromIndex(stmt);
    }

    public Optional<User> findOneByLogin(String login) {
        BoundStatement stmt = findOneByLoginStmt.bind();
        stmt.setString("login", login);
        return findOneFromIndex(stmt);
    }

    public List<User> findAll() {
        return mapper.map(session.execute(findAllStmt.bind())).all();
    }

    public User save(User user) {
        User oldUser = mapper.get(user.getId());
        if (oldUser != null) {
            if (!StringUtils.isEmpty(oldUser.getActivationKey()) && !oldUser.getActivationKey().equals(user.getActivationKey())) {
                session.execute(deleteByActivationKeyStmt.bind().setString("activation_key", oldUser.getActivationKey()));
            }
            if (!StringUtils.isEmpty(oldUser.getResetKey()) && !oldUser.getResetKey().equals(user.getResetKey())) {
                session.execute(deleteByResetKeyStmt.bind().setString("reset_key", oldUser.getResetKey()));
            }
            if (!StringUtils.isEmpty(oldUser.getLogin()) && !oldUser.getLogin().equals(user.getLogin())) {
                session.execute(deleteByLoginStmt.bind().setString("login", oldUser.getLogin()));
            }
            if (!StringUtils.isEmpty(oldUser.getEmail()) && !oldUser.getEmail().equals(user.getEmail())) {
                session.execute(deleteByEmailStmt.bind().setString("email", oldUser.getEmail()));
            }
        }
        BatchStatement batch = new BatchStatement();
        batch.add(mapper.saveQuery(user));
        if (!StringUtils.isEmpty(user.getActivationKey())) {
            batch.add(insertByActivationKeyStmt.bind()
                .setString("activation_key", user.getActivationKey())
                .setString("id", user.getId()));
        }
        if (!StringUtils.isEmpty(user.getResetKey())) {
          batch.add(insertByResetKeyStmt.bind()
              .setString("reset_key", user.getResetKey())
              .setString("id", user.getId()));
        }
        batch.add(insertByLoginStmt.bind()
            .setString("login", user.getLogin())
            .setString("id", user.getId()));
        batch.add(insertByEmailStmt.bind()
            .setString("email", user.getEmail())
            .setString("id", user.getId()));
        session.execute(batch);
        return user;
    }

    public void delete(User user) {
        BatchStatement batch = new BatchStatement();
        batch.add(mapper.deleteQuery(user));
        if (!StringUtils.isEmpty(user.getActivationKey())) {
            batch.add(deleteByActivationKeyStmt.bind().setString("activation_key", user.getActivationKey()));
        }
        if (!StringUtils.isEmpty(user.getResetKey())) {
            batch.add(deleteByResetKeyStmt.bind().setString("reset_key", user.getResetKey()));
        }
        batch.add(deleteByLoginStmt.bind().setString("login", user.getLogin()));
        batch.add(deleteByEmailStmt.bind().setString("email", user.getEmail()));
        session.execute(batch);
    }

    private Optional<User> findOneFromIndex(BoundStatement stmt) {
        ResultSet rs = session.execute(stmt);
        if (rs.isExhausted()) {
            return Optional.empty();
        }
        return Optional.ofNullable(rs.one().getString("id"))
            .map(id -> Optional.ofNullable(mapper.get(id)))
            .get();
    }
}