java - 需要服务但在构造函数中找不到

Question

我正在 jhipster 上做一个应用程序，扩展用户实体与用户有一对一的关系，所以我在扩展用户中扩展了用户 DTO，现在我在 UserResource 中遇到了麻烦

奇怪，因为它编译得很好，但现在我遇到了这个问题。

Compilation failure
    [ERROR] /Users/Misael-Mac/Proyectos/sigem/src/test/java/com/gits/sigem/web/rest/UserResourceIntTest.java:[108,37] constructor UserResource in class com.gits.sigem.web.rest.UserResource cannot be applied to given types;
    [ERROR]   required: com.gits.sigem.service.UserService,com.gits.sigem.repository.UserRepository,com.gits.sigem.service.MailService,com.gits.sigem.service.ExtendedUserService
    [ERROR]   found: com.gits.sigem.service.UserService,com.gits.sigem.repository.UserRepository,com.gits.sigem.service.MailService
    [ERROR]   reason: actual and formal argument lists differ in length

最糟糕的是，我检查到了最后一次提交，但问题仍然存在，所以我在提交之前犯了错误😥这是一项大量的工作，但我找不到问题。

UserResource.java 是这样的:

package com.gits.sigem.web.rest;

import com.gits.sigem.config.Constants;
import com.codahale.metrics.annotation.Timed;
import com.gits.sigem.domain.ExtendedUser;
import com.gits.sigem.domain.User;
import com.gits.sigem.repository.UserRepository;
import com.gits.sigem.security.AuthoritiesConstants;
import com.gits.sigem.service.ExtendedUserService;
import com.gits.sigem.service.MailService;
import com.gits.sigem.service.UserService;
import com.gits.sigem.service.dto.ExtendedUserDTO;
import com.gits.sigem.service.dto.UserDTO;
import com.gits.sigem.web.rest.errors.BadRequestAlertException;
import com.gits.sigem.web.rest.errors.EmailAlreadyUsedException;
import com.gits.sigem.web.rest.errors.LoginAlreadyUsedException;
import com.gits.sigem.web.rest.util.HeaderUtil;
import com.gits.sigem.web.rest.util.PaginationUtil;
import io.github.jhipster.web.util.ResponseUtil;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.annotation.Secured;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;

/**
 * REST controller for managing users.
 * <p>
 * This class accesses the User entity, and needs to fetch its collection of authorities.
 * <p>
 * For a normal use-case, it would be better to have an eager relationship between User and Authority,
 * and send everything to the client side: there would be no View Model and DTO, a lot less code, and an outer-join
 * which would be good for performance.
 * <p>
 * We use a View Model and a DTO for 3 reasons:
 * <ul>
 * <li>We want to keep a lazy association between the user and the authorities, because people will
 * quite often do relationships with the user, and we don't want them to get the authorities all
 * the time for nothing (for performance reasons). This is the #1 goal: we should not impact our users'
 * application because of this use-case.</li>
 * <li> Not having an outer join causes n+1 requests to the database. This is not a real issue as
 * we have by default a second-level cache. This means on the first HTTP call we do the n+1 requests,
 * but then all authorities come from the cache, so in fact it's much better than doing an outer join
 * (which will get lots of data from the database, for each HTTP call).</li>
 * <li> As this manages users, for security reasons, we'd rather have a DTO layer.</li>
 * </ul>
 * <p>
 * Another option would be to have a specific JPA entity graph to handle this case.
 */
@RestController
@RequestMapping("/api")
public class UserResource {

    private final Logger log = LoggerFactory.getLogger(UserResource.class);

    private final UserService userService;

    private final UserRepository userRepository;

    private final MailService mailService;

    private final ExtendedUserService  extendedUserService;

    public UserResource(UserService userService, UserRepository userRepository, MailService mailService, ExtendedUserService extendedUserService) {

        this.userService = userService;
        this.userRepository = userRepository;
        this.mailService = mailService;
        this.extendedUserService = extendedUserService;
    }

    /**
     * POST  /users  : Creates a new user.
     * <p>
     * Creates a new user if the login and email are not already used, and sends an
     * mail with an activation link.
     * The user needs to be activated on creation.
     *
     * @param userDTO the user to create
     * @return the ResponseEntity with status 201 (Created) and with body the new user, or with status 400 (Bad Request) if the login or email is already in use
     * @throws URISyntaxException if the Location URI syntax is incorrect
     * @throws BadRequestAlertException 400 (Bad Request) if the login or email is already in use
     */
    @PostMapping("/users")
    @Timed
    @Secured(AuthoritiesConstants.ADMIN)
    public ResponseEntity<User> createUser(@Valid @RequestBody UserDTO userDTO) throws URISyntaxException {
        log.debug("REST request to save User : {}", userDTO);

        if (userDTO.getId() != null) {
            throw new BadRequestAlertException("A new user cannot already have an ID", "userManagement", "idexists");
            // Lowercase the user login before comparing with database
        } else if (userRepository.findOneByLogin(userDTO.getLogin().toLowerCase()).isPresent()) {
            throw new LoginAlreadyUsedException();
        } else if (userRepository.findOneByEmailIgnoreCase(userDTO.getEmail()).isPresent()) {
            throw new EmailAlreadyUsedException();
        } else {
            User newUser = userService.createUser(userDTO);
            mailService.sendCreationEmail(newUser);
            return ResponseEntity.created(new URI("/api/users/" + newUser.getLogin()))
                .headers(HeaderUtil.createAlert( "userManagement.created", newUser.getLogin()))
                .body(newUser);
        }
    }
    /**
     * POST  /users-and-extendedUser  : Creates a new user and extendeduser.
     * <p>
     * Creates a new user if the login and email are not already used, and sends an
     * mail with an activation link.
     * The user needs to be activated on creation.
     *
     * @param extendedUserDTO the user to create
     * @return the ResponseEntity with status 201 (Created) and with body the new user, or with status 400 (Bad Request) if the login or email is already in use
     * @throws URISyntaxException if the Location URI syntax is incorrect
     * @throws BadRequestAlertException 400 (Bad Request) if the login or email is already in use
     */
    @PostMapping("/users-and-extendedUser")
    @Timed
    @Secured(AuthoritiesConstants.ADMIN)
    public ResponseEntity<User> createUserAndExtendedUser(@Valid @RequestBody ExtendedUserDTO extendedUserDTO) throws URISyntaxException {


        if (extendedUserDTO.getId() != null) {
            throw new BadRequestAlertException("A new user cannot already have an ID", "userManagement", "idexists");
            // Lowercase the user login before comparing with database
        } else if (userRepository.findOneByLogin(extendedUserDTO.getLogin().toLowerCase()).isPresent()) {
            throw new LoginAlreadyUsedException();
        } else if (userRepository.findOneByEmailIgnoreCase(extendedUserDTO.getEmail()).isPresent()) {
            throw new EmailAlreadyUsedException();
        } else {
            User newUser = userService.createUser(extendedUserDTO);
            //mailService.sendCreationEmail(newUser);
            ExtendedUserDTO newExtendedUser = extendedUserService.save(extendedUserDTO);
            newExtendedUser.setUsuarioId(newUser.getId());
            newExtendedUser.setPuesto(extendedUserDTO.getPuesto());
            extendedUserService.save(newExtendedUser);

            return ResponseEntity.created(new URI("/api/users/" + newUser.getLogin()))
                .headers(HeaderUtil.createAlert( "userManagement.created", newUser.getLogin()))
                .body(newUser);
        }
    }

    /*
     * PUT /users : Updates an existing User.
     *
     * @param userDTO the user to update
     * @return the ResponseEntity with status 200 (OK) and with body the updated user
     * @throws EmailAlreadyUsedException 400 (Bad Request) if the email is already in use
     * @throws LoginAlreadyUsedException 400 (Bad Request) if the login is already in use
     *
    @PutMapping("/users")
    @Timed
    @Secured(AuthoritiesConstants.ADMIN)
    public ResponseEntity<UserDTO> updateUser(@Valid @RequestBody UserDTO userDTO) {
        log.debug("REST request to update User : {}", userDTO);
        Optional<User> existingUser = userRepository.findOneByEmailIgnoreCase(userDTO.getEmail());
        if (existingUser.isPresent() && (!existingUser.get().getId().equals(userDTO.getId()))) {
            throw new EmailAlreadyUsedException();
        }
        existingUser = userRepository.findOneByLogin(userDTO.getLogin().toLowerCase());
        if (existingUser.isPresent() && (!existingUser.get().getId().equals(userDTO.getId()))) {
            throw new LoginAlreadyUsedException();
        }
        Optional<UserDTO> updatedUser = userService.updateUser(userDTO);
         return ResponseUtil.wrapOrNotFound(updatedUser,
            HeaderUtil.createAlert("userManagement.updated", userDTO.getLogin()));
    }*/

    /*
     * PUT /users-and-extendedUser : Updates an existing User and extendedUser.
     *
     * @param extendedUserDTO the user to update
     * @return the ResponseEntity with status 200 (OK) and with body the updated user
     * @throws EmailAlreadyUsedException 400 (Bad Request) if the email is already in use
     * @throws LoginAlreadyUsedException 400 (Bad Request) if the login is already in use

    @PutMapping("/users-and-extendedUser")
    @Timed
    @Secured(AuthoritiesConstants.ADMIN)
    public ResponseEntity<UserDTO> updateUser(@Valid @RequestBody ExtendedUserDTO extendedUserDTO) {

         Optional<User> existingUser = userRepository.findOneByEmailIgnoreCase(extendedUserDTO.getEmail());
        if (existingUser.isPresent() && (!existingUser.get().getId().equals(extendedUserDTO.getId()))) {
            log.debug("error nombre traido : {}", extendedUserDTO.getUsuarioId());
            throw new EmailAlreadyUsedException();
        }
        existingUser = userRepository.findOneByLogin(extendedUserDTO.getLogin().toLowerCase());
        if (existingUser.isPresent() && (!existingUser.get().getId().equals(extendedUserDTO.getId()))) {
            log.debug("error nombre traido : {}", extendedUserDTO.getUsuarioId());
            throw new LoginAlreadyUsedException();
        }

        Optional<UserDTO> updatedUser = userService.updateUser(extendedUserDTO);
        ExtendedUser updateExtendedUser = existingUser.get().getExtendedUser();
        updateExtendedUser.setPuesto(extendedUserDTO.getPuesto());
        updateExtendedUser.setSueldo(extendedUserDTO.getSueldo());
        updateExtendedUser.setFechaIngreso(extendedUserDTO.getFechaIngreso());
        updateExtendedUser.setAreas(extendedUserDTO.getAreas());
        extendedUserService.save(updateExtendedUser);
        return ResponseUtil.wrapOrNotFound(updatedUser,
            HeaderUtil.createAlert("userManagement.updated", extendedUserDTO.getLogin()));
    }*/

    /**
     * GET /users : get all users.
     *
     * @param pageable the pagination information
     * @return the ResponseEntity with status 200 (OK) and with body all users
     */
    @GetMapping("/users")
    @Timed
    public ResponseEntity<List<UserDTO>> getAllUsers(Pageable pageable) {
        final Page<UserDTO> page = userService.getAllManagedUsers(pageable);
        HttpHeaders headers = PaginationUtil.generatePaginationHttpHeaders(page, "/api/users");
        return new ResponseEntity<>(page.getContent(), headers, HttpStatus.OK);
    }

    /**
     * @return a string list of the all of the roles
     */
    @GetMapping("/users/authorities")
    @Timed
    @Secured(AuthoritiesConstants.ADMIN)
    public List<String> getAuthorities() {
        return userService.getAuthorities();
    }

    /**
     * GET /users/:login : get the "login" user.
     *
     * @param login the login of the user to find
     * @return the ResponseEntity with status 200 (OK) and with body the "login" user, or with status 404 (Not Found)
     */
    @GetMapping("/users/{login:" + Constants.LOGIN_REGEX + "}")
    @Timed
    @Transactional(propagation=Propagation.REQUIRED)
    public ResponseEntity<ExtendedUserDTO> getUser(@PathVariable String login) {
        log.debug("REST request to get User : {}", login);
         User user = userService.getUserWithAuthoritiesByLogin(login).get();
         ExtendedUserDTO extendedUserDTO = new ExtendedUserDTO(user);
        return new ResponseEntity<>(extendedUserDTO, HttpStatus.OK);
    }

    /**
     * DELETE /users/:login : delete the "login" User.
     *
     * @param login the login of the user to delete
     * @return the ResponseEntity with status 200 (OK)
     */
    @DeleteMapping("/users/{login:" + Constants.LOGIN_REGEX + "}")
    @Timed
    @Secured(AuthoritiesConstants.ADMIN)
    public ResponseEntity<Void> deleteUser(@PathVariable String login) {
        log.debug("REST request to delete User: {}", login);
        userService.deleteUser(login);
        return ResponseEntity.ok().headers(HeaderUtil.createAlert( "userManagement.deleted", login)).build();
    }
}

我认为问题不在这里，也许是 ExtendedUserService 中的某些内容？

更新

  @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);
        cacheManager.getCache(UserRepository.USERS_BY_LOGIN_CACHE).clear();
        cacheManager.getCache(UserRepository.USERS_BY_EMAIL_CACHE).clear();
        UserResource userResource = new UserResource(userService, userRepository, mailService);
        this.restUserMockMvc = MockMvcBuilders.standaloneSetup(userResource)
            .setCustomArgumentResolvers(pageableArgumentResolver)
            .setControllerAdvice(exceptionTranslator)
            .setMessageConverters(jacksonMessageConverter)
            .build();
    }

好吧，问题就在这里，但现在又可以工作了，现在我知道 Jhipster 制作这个文件来检测重要的更改。

Answer 1

当您更改资源文件的构造函数时，您还需要在资源的测试文件中进行相同的更改。错误指出原因:实际参数列表和形式参数列表的长度不同

例如，您将 ExtendedUserService 添加到 UserResource 中的构造函数:

public UserResource(UserService userService, UserRepository userRepository, MailService mailService, ExtendedUserService extendedUserService) {
    this.userService = userService;
    this.userRepository = userRepository;
    this.mailService = mailService;
    this.extendedUserService = extendedUserService;
}

因此，您需要将 ExtendedUserService 添加到 UserResourceIntTest，并将其包含在对 UserResource 构造函数的调用中:

@Autowired
private ExtendedUserService extendedUserService;
...
...
UserResource userResource = new UserResource(userService, userRepository, mailService, extendedUserService);