Spring测试中报错Class not found: "com.atguigu.Spring6.Test_user"

这个错误可能是因为测试类的包名或类名有误导致的。可以检查以下几点：

1. 检查测试类的包名是否正确，包名应该与实际的包名一致。

2. 检查测试类的类名是否正确，类名应该与实际的类名一致。

3. 检查测试类是否在正确的测试目录下，测试类应该位于src/test/java目录下。

4. 检查项目的类路径是否正确，如果测试类所依赖的类没有在类路径中，也会导致该错误。

如果以上方法都不能解决问题，可以尝试重新创建测试类，或者检查项目的依赖是否正确。

相关问题

Spring Boot Security OAuth2 JWT完整示例

Spring Boot Security是一个非常流行的安全框架，可以帮助开发人员实现各种安全功能。其中，OAuth2和JWT是两个非常重要的安全技术，可以用于实现授权和认证。下面是一个基于Spring Boot Security的完整示例，演示如何使用OAuth2和JWT实现安全功能。

1. 创建一个Spring Boot项目

使用Spring Initializr创建一个新的Spring Boot项目，添加以下依赖：

- Spring Web
- Spring Security
- Spring Data JPA
- H2 Database
- Spring Security OAuth2
- jjwt

2. 添加配置文件

在application.properties文件中添加以下配置：

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=create-drop
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
spring.security.oauth2.client.registration.myapp.client-id=myapp
spring.security.oauth2.client.registration.myapp.client-secret=myappsecret
spring.security.oauth2.client.registration.myapp.scope=read,write
spring.security.oauth2.client.provider.myapp.authorization-uri=http://localhost:8080/oauth/authorize
spring.security.oauth2.client.provider.myapp.token-uri=http://localhost:8080/oauth/token
spring.security.oauth2.client.provider.myapp.user-info-uri=http://localhost:8080/userinfo
spring.security.oauth2.client.provider.myapp.user-name-attribute=name

这些配置将用于配置数据源、Hibernate、H2控制台和OAuth2。

3. 创建实体类和仓库

创建一个User实体类，用于表示用户信息：

@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String username;
    
    @Column(nullable = false)
    private String password;
    
    @Column(nullable = false)
    private String email;
    
    // getters and setters
}

创建一个UserRepository接口，用于操作User实体类：

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
}

4. 创建用户服务

创建一个UserService接口，用于定义获取用户和创建用户的方法：

public interface UserService {
    User createUser(String username, String password, String email);
    Optional<User> getUserByUsername(String username);
}

创建一个UserServiceImpl实现UserService接口，用于实现上述方法：

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public User createUser(String username, String password, String email) {
        User user = new User();
        user.setUsername(username);
        user.setPassword(passwordEncoder.encode(password));
        user.setEmail(email);
        return userRepository.save(user);
    }

    @Override
    public Optional<User> getUserByUsername(String username) {
        return userRepository.findByUsername(username);
    }
}

5. 配置Spring Security

创建一个WebSecurityConfig类，用于配置Spring Security：

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserService userService;
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/oauth/**").permitAll()
                .anyRequest().authenticated()
                .and()
                .csrf().disable()
                .formLogin().disable()
                .httpBasic().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }
    
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(username -> userService.getUserByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("User not found: " + username)))
            .passwordEncoder(passwordEncoder());
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

这个配置类将所有请求都需要进行认证，但是允许OAuth2请求。同时，禁用了CSRF、表单登录、HTTP基本认证和会话管理。

6. 配置OAuth2

创建一个OAuth2Config类，用于配置OAuth2：

@Configuration
@EnableAuthorizationServer
public class OAuth2Config extends AuthorizationServerConfigurerAdapter {
    @Autowired
    private AuthenticationManager authenticationManager;
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private PasswordEncoder passwordEncoder;
    
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("myapp")
                .secret(passwordEncoder.encode("myappsecret"))
                .authorizedGrantTypes("authorization_code", "refresh_token")
                .scopes("read", "write")
                .redirectUris("http://localhost:8081/login/oauth2/code/myapp");
    }
    
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.authenticationManager(authenticationManager)
                .userDetailsService(username -> userService.getUserByUsername(username)
                        .orElseThrow(() -> new UsernameNotFoundException("User not found: " + username)))
                .accessTokenConverter(accessTokenConverter())
                .pathMapping("/oauth/token", "/signin");
    }
    
    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey("secret");
        return converter;
    }
    
    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(accessTokenConverter());
    }
}

这个配置类定义了一个OAuth2客户端，将授权码和刷新令牌作为授权类型，并允许读取和写入作用域。同时，定义了一个端点配置，将认证管理器、用户详情服务、访问令牌转换器和令牌存储配置到端点上。

7. 创建控制器

创建一个UserController类，用于处理用户相关的请求：

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping
    public User createUser(@RequestBody UserDto userDto) {
        return userService.createUser(userDto.getUsername(), userDto.getPassword(), userDto.getEmail());
    }

    @GetMapping("/{username}")
    public User getUser(@PathVariable String username) {
        return userService.getUserByUsername(username)
                .orElseThrow(() -> new NotFoundException("User not found: " + username));
    }
}

这个控制器中定义了创建用户和获取用户的方法。

8. 创建JWT过滤器

创建一个JwtFilter类，用于在请求中验证JWT令牌：

public class JwtFilter extends OncePerRequestFilter {
    private static final String AUTHORIZATION_HEADER = "Authorization";
    
    @Autowired
    private JwtAccessTokenConverter accessTokenConverter;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String authorizationHeader = request.getHeader(AUTHORIZATION_HEADER);
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            String token = authorizationHeader.substring(7);
            Authentication authentication = accessTokenConverter.extractAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        filterChain.doFilter(request, response);
    }
}

这个过滤器会从请求头中获取JWT令牌，并使用令牌转换器验证令牌。如果验证通过，则将用户认证信息存储到Spring Security上下文中。

9. 注册JWT过滤器

在WebSecurityConfig类中，添加以下配置：

@Bean
public JwtFilter jwtFilter() {
    return new JwtFilter();
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.addFilterBefore(jwtFilter(), UsernamePasswordAuthenticationFilter.class);
    // ...
}

这个配置将JwtFilter注册到Spring Security过滤器链中。

10. 创建JWT工具类

创建一个JwtUtils类，用于生成和解析JWT令牌：

public class JwtUtils {
    public static final String SUBJECT = "myapp";

    public static String generateToken(User user) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("sub", SUBJECT);
        claims.put("id", user.getId());
        claims.put("username", user.getUsername());
        claims.put("email", user.getEmail());
        Date now = new Date();
        Date expiration = new Date(now.getTime() + 60 * 60 * 1000);
        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(expiration)
                .signWith(SignatureAlgorithm.HS256, "secret")
                .compact();
    }

    public static Long getUserIdFromToken(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey("secret")
                .parseClaimsJws(token)
                .getBody();
        return claims.get("id", Long.class);
    }
}

这个工具类将用户信息存储到JWT令牌中，并使用HS256算法进行签名。

11. 创建DTO类

创建一个UserDto类，用于接收创建用户的请求：

public class UserDto {
    private String username;
    private String password;
    private String email;

    // getters and setters
}

12. 测试

启动应用程序，并使用以下命令创建一个用户：

curl -X POST -H 'Content-Type: application/json' -d '{"username":"test","password":"test123","email":"test@example.com"}' http://localhost:8080/users

使用以下命令获取访问令牌：

curl -X POST -vu myapp:myappsecret http://localhost:8080/oauth/token -H 'Accept: application/json' -d 'grant_type=authorization_code&code={CODE}&redirect_uri=http://localhost:8081/login/oauth2/code/myapp'

将{CODE}替换为授权码，并将返回的访问令牌用于获取用户信息：

curl -H 'Authorization: Bearer {ACCESS_TOKEN}' http://localhost:8080/users/test

将{ACCESS_TOKEN}替换为访问令牌，在请求头中发送即可。

以上就是一个完整的Spring Boot Security OAuth2 JWT示例，演示了如何实现授权和认证。

使用springboot简单整合springsecurity和mybatis，实现权限管理

1. 创建一个Spring Boot项目，并添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>

2. 创建一个用户实体类和一个用户DAO接口，用于查询用户信息。

public class User {
    private Long id;
    private String username;
    private String password;
    private List<String> roles;

    // getter and setter
}

public interface UserDAO {
    User findByUsername(String username);
}

3. 创建一个自定义的UserDetailsService，用于加载用户信息，并实现UserDetails接口。

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserDAO userDAO;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userDAO.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found");
        }
        return new org.springframework.security.core.userdetails.User(
                user.getUsername(),
                user.getPassword(),
                AuthorityUtils.createAuthorityList(user.getRoles().toArray(new String[0]))
        );
    }
}

4. 创建一个SecurityConfig类，用于配置Spring Security。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .logout()
                .logoutUrl("/logout")
                .logoutSuccessUrl("/")
                .invalidateHttpSession(true)
                .deleteCookies("JSESSIONID")
                .and()
                .csrf().disable();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }
}

5. 创建一个AdminController类，用于测试权限控制。

@RestController
@RequestMapping("/admin")
public class AdminController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Admin!";
    }
}

6. 在application.properties中配置MyBatis和数据库信息。

mybatis.mapper-locations=classpath:mapper/*.xml
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

7. 创建一个测试类，测试权限控制。

@RunWith(SpringRunner.class)
@SpringBootTest
public class SecurityTest {

    @Autowired
    private WebApplicationContext context;

    private MockMvc mockMvc;

    @Before
    public void setUp() {
        mockMvc = MockMvcBuilders.webAppContextSetup(context).apply(springSecurity()).build();
    }

    @Test
    public void testAdmin() throws Exception {
        mockMvc.perform(get("/admin/hello")
                .with(user("admin").password("admin").roles("ADMIN")))
                .andExpect(status().isOk())
                .andExpect(content().string("Hello, Admin!"));
    }

    @Test
    public void testUser() throws Exception {
        mockMvc.perform(get("/admin/hello")
                .with(user("user").password("user").roles("USER")))
                .andExpect(status().isForbidden());
    }
}

运行测试类，可以看到测试通过，权限控制生效。

以上就是使用Spring Boot整合Spring Security和MyBatis实现权限管理的简单示例。