SpringBoot框架面试专题（初级-中级）-第六节

关注

原创最新推荐文章于 2026-06-03 13:42:21 发布 372 阅读 AI 写同款· GEO 优化 ›

微服务系列：分布式事务 Spring Cloud Alibaba 之 Seata 实战篇这篇中我们就要项目实战中来使用 Seata 了，毕竟学习它就是为了实战中使用的。其实 Seata 使用起来很简单，主要就是使用 @GlobalTransactional注解，但是搭建过程却还是稍微有点复杂的。话不多说，开始今天的学习。一、前言本案例使用的是 Seata 的 AT 模式由于篇幅有限，本文只贴出核心代码和配置，完整代码地址：cloud-seata: seata demo - Gitee.com 本案例使用 Nacos 作为注册中心，使用 Nacos 作为配置中心 1. 版本阅读详情

欢迎大家一起探讨相关问题，我们共同进步，喜欢的话可以关注点赞，后续会持续更新，谢谢～

问题：

1.如何在Spring Boot中实现分布式事务？常用的分布式事务框架有哪些？

解析：

在分布式系统中，由于事务涉及到多个服务的操作，因此需要采用分布式事务来保证数据的一致性和完整性。在Spring Boot中，可以使用多种分布式事务框架来实现分布式事务。常用的分布式事务框架有以下几种：

Spring Cloud Alibaba Seata：Seata是一款开源的分布式事务解决方案，由阿里巴巴开源。Seata提供了完整的分布式事务解决方案，包括全局事务协调器、本地事务管理器、分布式事务ID生成器等组件。在Spring Boot中，可以通过引入Seata依赖，配置Seata Server地址，并使用Seata提供的注解来实现分布式事务。
TCC-Transaction：TCC-Transaction是一款基于两阶段提交协议的分布式事务解决方案。TCC-Transaction通过定义Try、Confirm、Cancel三个操作来实现分布式事务，可以在不同的服务之间进行分布式事务的提交和回滚。在SpringBoot中，可以使用TCC-Transaction框架提供的注解和工具类来实现分布式事务。
Atomikos：Atomikos是一款流行的分布式事务管理器，可以在多个服务之间实现分布式事务的提交和回滚。在Spring Boot中，可以使用Atomikos提供的Spring Boot Starter和注解来实现分布式事务。
Bitronix：Bitronix是一款开源的分布式事务管理器，可以在多个服务之间实现分布式事务的提交和回滚。在Spring Boot中，可以使用Bitronix提供的Spring Boot Starter和注解来实现分布式事务。

在Spring Boot中，实现分布式事务主要有以下几个步骤：

1.引入分布式事务依赖

在pom.xml文件中添加相应的分布式事务框架依赖，例如Seata：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
    <version>${seata.version}</version>
</dependency>

2.配置分布式事务在Spring Boot中，需要配置分布式事务框架的相关属性，例如Seata的配置文件：

spring.cloud.alibaba.seata.tx-service-group=my_tx_group
spring.cloud.alibaba.seata.service-group=my_group
spring.cloud.alibaba.seata.enable-auto-data-source-proxy=true
spring.cloud.alibaba.seata.enabled=true

在上面的示例中，我们配置了Seata的tx-service-group、service-group和enable-auto-data-source-proxy属性，然后启用了Seata。

3.使用注解实现分布式事务

在Spring Boot中，可以使用分布式事务框架提供的注解来实现分布式事务，例如Seata的@GlobalTransactional注解：

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @GlobalTransactional
    public void transfer(String from, String to, double amount) {
        User fromUser = userDao.findById(from);
        User toUser = userDao.findById(to);

        fromUser.setBalance(fromUser.getBalance() - amount);
        toUser.setBalance(toUser.getBalance() + amount);

        userDao.update(fromUser);
        userDao.update(toUser);
    }
}

在上面的示例中，我们定义了一个UserService类，其中transfer()方法使用@GlobalTransactional注解来标注分布式事务。在方法中，我们定义了两个用户，并更新其余额信息，然后通过调用UserDao的update()方法将更新后的用户信息写入数据库。由于使用了@GlobalTransactional注解，Seata会在方法执行前开启一个全局事务，在方法执行完成后进行提交或回滚操作，确保两个用户的余额信息在数据库中的更新操作是原子性的。

需要注意的是，不同的分布式事务框架可能需要使用不同的注解来实现分布式事务，具体使用方式需要参考相应的文档。

在实际应用中，分布式事务的实现涉及到多个服务之间的协作，需要仔细考虑分布式事务的一致性、可靠性和性能等方面的问题。因此，在选择分布式事务框架时需要根据实际应用场景和需求进行综合评估和选择。

问题：

2.如何在Spring Boot中实现JWT认证？常用的JWT认证框架有哪些？

解析：

在Web应用程序中，常常需要对用户进行认证和授权来保护资源的安全性。JWT（JSON Web Token）是一种轻量级的认证和授权机制，可以在不需要在服务端存储会话信息的情况下实现认证和授权。在Spring Boot中，可以使用多种JWT认证框架来实现JWT认证。常用的JWT认证框架有以下几种：

Spring Security JWT：Spring Security是Spring框架提供的安全性解决方案，可以用于实现认证、授权和攻击防护等功能。Spring Security提供了对JWT的支持，可以在Spring Boot中使用Spring Security JWT来实现JWT认证。使用Spring Security JWT需要定义一个JwtTokenFilter类，并将其注册到Spring Security中。
Auth0 JWT：Auth0是一个提供身份验证和授权解决方案的云服务，提供了多种身份验证和授权机制，包括JWT。Auth0提供了Java JWT库，可以在Spring Boot中使用Auth0 JWT来实现JWT认证。使用Auth0 JWT需要在pom.xml文件中添加Java JWT依赖，并编写一个JwtTokenProvider类，该类负责生成、验证和解析JWT。
Nimbus JWT：Nimbus JWT是一个开源的Java JWT实现库，提供了多种JWT相关的API和工具。在Spring Boot中，可以使用Nimbus JWT提供的JwtAuthenticationFilter和JwtTokenAuthenticationProvider来实现JWT认证。JwtAuthenticationFilter类负责从HTTP请求中提取JWT，并将其传递给JwtTokenAuthenticationProvider进行验证和解析。

在Spring Boot中，实现JWT认证主要有以下几个步骤：

1.引入JWT依赖

在pom.xml文件中添加相应的JWT框架依赖，例如Spring Security JWT：

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-jwt</artifactId>
    <version>${spring-security.version}</version>
</dependency>

2.编写JwtTokenProvider类

在JwtTokenProvider类中定义生成、验证和解析JWT的方法，示例代码如下：

@Component
public class JwtTokenProvider {
    private static final String SECRET_KEY = "my_secret_key";
    private static final long EXPIRATION_TIME = 86400000L;

    public String generateToken(Authentication authentication) {
        User user= (User) authentication.getPrincipal();
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + EXPIRATION_TIME);

        return Jwts.builder()
                .setSubject(user.getUsername())
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
            return true;
        } catch (SignatureException ex) {
            System.out.println("Invalid JWT signature");
        } catch (MalformedJwtException ex) {
            System.out.println("Invalid JWT token");
        } catch (ExpiredJwtException ex) {
            System.out.println("Expired JWT token");
        } catch (UnsupportedJwtException ex) {
            System.out.println("Unsupported JWT token");
        } catch (IllegalArgumentException ex) {
            System.out.println("JWT claims string is empty.");
        }
        return false;
    }

    public String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody();
        return claims.getSubject();
    }
}

在上面的示例中，我们定义了一个JwtTokenProvider类，其中包括三个方法：generateToken()、validateToken()和getUsernameFromToken()。在generateToken()方法中，我们使用指定的密钥生成JWT，并设置JWT的过期时间和负载，然后使用HS512算法对JWT进行签名。在validateToken()方法中，我们使用指定的密钥验证JWT的签名和有效期，并处理可能出现的异常。在getUsernameFromToken()方法中，我们从JWT的负载中提取用户名。

需要注意的是，实际应用中应该将密钥和过期时间等敏感信息存储在配置文件中，以避免泄露。

3.编写JwtTokenFilter类

在JwtTokenFilter类中定义过滤器，用于从HTTP请求中提取JWT，并将其传递给JwtTokenProvider进行验证和解析，示例代码如下：

@Component
public class JwtTokenFilter extends OncePerRequestFilter {
    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String jwt = getJwtFromRequest(request);

        if (StringUtils.hasText(jwt) && jwtTokenProvider.validateToken(jwt)) {
            String username = jwtTokenProvider.getUsernameFromToken(jwt);
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }

        filterChain.doFilter(request, response);
    }

    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

在上面的示例中，我们定义了一个JwtTokenFilter类，其中包括两个方法：doFilterInternal()和getJwtFromRequest()。在doFilterInternal()方法中，我们从HTTP请求中提取JWT，并使用JwtTokenProvider进行验证和解析。如果JWT有效，则将用户信息保存到SecurityContextHolder中，以便后续的授权操作。在getJwtFromRequest()方法中，我们从HTTP请求头中提取JWT字符串。

4.配置JwtTokenFilter

在Spring Boot中，需要将JwtTokenFilter注册到Spring Security中，示例代码如下：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtTokenFilter jwtTokenFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable().authorizeRequests()
                .antMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated();

        http.addFilterBefore(jwtTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

在上面的示例中，我们定义了一个SecurityConfig类，其中包括一个configure()方法，用于配置Spring Security的认证和授权规则。在该方法中，我们禁用了CSRF保护，并设置了/api/auth/**路径下的请求不需要认证即可访问，其他请求需要进行认证。然后，我们将JwtTokenFilter注册到Spring Security中，以便在每个请求中提取JWT并进行认证和授权操作。

需要注意的是，实际应用中可能需要根据实际需求进行定制化配置，例如设置JWT的过期时间、定义不需要认证的路径等。

综上所述，实现JWT认证的步骤主要包括引入JWT依赖、编写JwtTokenProvider类、编写JwtTokenFilter类和配置JwtTokenFilter。在选择JWT认证框架时，需要根据实际应用场景和需求进行综合评估和选择。

问题：

3.如何在Spring Boot中实现分布式配置中心？常用的分布式配置中心有哪些？

解析：

在Spring Boot中，可以通过使用分布式配置中心，来实现在多个应用程序中共享配置信息，并且能够动态修改配置信息。常用的分布式配置中心有以下几种：

Spring Cloud Config：Spring Cloud Config是Spring Cloud提供的分布式配置中心，可以将配置信息存储在Git、SVN、本地文件系统等后端存储中，并且提供了REST API接口和Web界面，方便用户管理配置信息。在Spring Boot中，可以通过引入spring-cloud-starter-config依赖，并配置application.yml文件中的spring.cloud.config.server属性来搭建Spring Cloud Config服务。
Apache ZooKeeper：Apache ZooKeeper是一个分布式协调服务，可以用于存储分布式配置信息。在Spring Boot中，可以通过引入curator-framework依赖，并编写相应的ZooKeeper配置类，来实现分布式配置中心。
Consul：Consul是一个开源的服务发现和配置管理工具，可以用于存储分布式配置信息。在Spring Boot中，可以通过引入spring-cloud-starter-consul-config依赖，并配置application.yml文件中的spring.cloud.consul.config属性来搭建Consul配置中心。
Etcd：Etcd是一个分布式键值存储系统，可以用于存储分布式配置信息。在Spring Boot中，可以通过引入etcd4j依赖，并编写相应的Etcd配置类，来实现分布式配置中心。

在Spring Boot中，实现分布式配置中心主要有以下几个步骤：

1.引入分布式配置中心依赖

根据选择的分布式配置中心，需要在pom.xml中添加相应的依赖，例如Spring Cloud Config：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

2.配置分布式配置中心

根据选择的分布式配置中心，需要在application.yml文件中配置相应的属性，例如Spring Cloud Config：

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/my-org/my-repo
          search-paths: '{application}'
          username: my-username
          password: my-password

在上面的示例中，我们配置了Spring Cloud Config服务从GitHub上获取配置信息，其中包括Git仓库的URI、搜索路径、用户名和密码等信息。需要注意的是，实际应用中应该根据实际需求进行定制化配置。

3.获取配置信息

在应用程序中，可以通过使用Spring Boot提供的@Value注解或者@ConfigurationProperties注解来获取配置信息，例如：

@RestController
public class MyController {
    @Value("${my.property}")
    private String myProperty;

    @GetMapping("/my-property")
    public String getMyProperty() {
        return myProperty;
    }
}

在上面的示例中，我们定义了一个MyController类，其中使用@Value注解来获取名为my.property的配置信息，并在getMyProperty()方法中返回该配置信息。需要注意的是，如果在分布式配置中心中修改了该配置信息，则应用程序会自动获取最新的配置信息。

综上所述，实现分布式配置中心的步骤主要包括引入分布式配置中心依赖、配置分布式配置中心、获取配置信息。在选择分布式配置中心时，需要根据实际应用场景和需求进行综合评估和选择。

问题：

4.如何在Spring Boot中优化SQL查询性能？常用的优化方式有哪些？

解析：

在Spring Boot应用程序中，SQL查询性能的优化是一个非常关键的问题，可以通过优化SQL查询来提高应用程序的响应速度和性能。常用的SQL查询优化方式有以下几种：

1.使用索引

索引是数据库中常用的优化方式之一，可以加快数据库的查询速度。在使用Spring Boot操作数据库时，可以通过在实体类中使用@Index或@Indexes注解来创建索引，或者在数据库中手动创建索引。需要注意的是，过多的索引会降低更新和插入操作的性能，因此应该避免创建过多的索引。

2.减少查询返回的列数

查询返回的列数越少，查询的速度就越快。在编写SQL查询语句时，应该尽可能地减少查询返回的列数，只查询所需的数据。在使用Spring Boot操作数据库时，可以通过使用Projections来只查询需要的列，例如：

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u.id, u.username FROM User u WHERE u.id = :id")
    Object[] findUsernameById(@Param("id") Long id);

在上面的示例中，我们使用了Projections来只查询用户的id和username两个字段，而不是查询整个User实体。

3. 避免使用SELECT *

使用SELECT *查询语句会查询表中的所有列，包括不需要的列，会浪费数据库资源和带来性能问题。在编写SQL查询语句时，应该避免使用SELECT *语句，只查询所需的列。

4. 使用合适的数据类型

在数据库中使用合适的数据类型可以提高查询效率。例如，使用int类型代替varchar类型可以提高查询效率，因为int类型的比较速度更快。在使用Spring Boot操作数据库时，应该尽可能地使用合适的数据类型，避免使用不必要的数据类型。

5. 使用分页查询

当需要查询大量数据时，应该使用分页查询，避免一次性查询所有数据。在使用Spring Boot操作数据库时，可以使用Spring Data提供的分页查询功能，例如：

public interface UserRepository extends JpaRepository<User, Long> {
    Page<User> findAll(Pageable pageable);
}

在上面的示例中，我们使用Spring Data提供的分页查询功能来查询所有用户数据，并进行分页处理。需要注意的是，在进行分页查询时，应该合理设置分页大小，避免一次性查询过多数据造成性能问题。

6.使用预编译语句

使用预编译语句可以避免SQL注入攻击，并且可以提高查询效率。在使用Spring Boot操作数据库时，应该尽可能地使用预编译语句，例如：

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u FROM User u WHERE u.username = ?1")
    User findByUsername(String username);
}

在上面的示例中，我们使用了预编译语句来查询用户名为指定值的用户。

7.避免使用子查询

子查询会增加数据库的负担和查询时间，应该尽可能地避免使用。在编写SQL查询语句时，应该尽可能地避免使用子查询语句。

综上所述，优化SQL查询的方式主要包括使用索引、减少查询返回的列数、避免使用SELECT *、使用合适的数据类型、使用分页查询、使用预编译语句和避免使用子查询。在实际应用中，应该根据实际场景和需求综合评估和选择优化方式，以提高SQL查询性能和应用程序的响应速度。

问题：

5.如何在Spring Boot中实现高并发处理？常用的高并发处理方式有哪些？

解析：

在Spring Boot应用程序中，实现高并发处理是提高应用程序性能和稳定性的关键。常用的高并发处理方式有以下几种：

1.使用缓存

缓存是提高应用程序性能的有效方式之一，可以减少数据库查询次数，降低数据库负载。在Spring Boot中，可以通过使用Spring Cache提供的缓存功能来实现缓存，例如使用@Cacheable注解对方法进行缓存。

2.使用消息队列

使用消息队列可以将请求和处理分离，提高应用程序的处理能力和稳定性。在Spring Boot中，可以使用Spring AMQP提供的消息队列功能，例如使用@RabbitListener注解监听消息队列。

3.使用线程池

使用线程池可以提高应用程序的并发处理能力。在Spring Boot中，可以通过使用ThreadPoolTaskExecutor来实现线程池，例如：

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    @Bean(name = "taskExecutor")
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(100);
        executor.setQueueCapacity(1000);
        executor.setThreadNamePrefix("MyThread-");
        executor.initialize();
        return executor;
    }
}

在上面的示例中，我们使用ThreadPoolTaskExecutor来创建一个线程池，设置核心线程数为10，最大线程数为100，队列容量为1000，线程名前缀为"MyThread-"。

4.使用分布式锁

使用分布式锁可以避免多个线程同时访问同一个资源，引发的并发问题。在Spring Boot中，可以使用Spring Integration提供的分布式锁功能，例如使用@Lock注解对方法进行加锁。

5.使用异步处理

使用异步处理可以将请求和处理分离，提高应用程序的处理能力和稳定性。在Spring Boot中，可以使用@Async注解实现异步处理，例如：

@Service
public class UserService {
    
    @Async
    public void createUser(User user) {
        // 处理用户创建逻辑
    }
}

在上面的示例中，我们使用@Async注解将createUser方法标记为异步处理方法。

综上所述，实现高并发处理的方式包括使用缓存、消息队列、线程池、分布式锁和异步处理等多种方式。在实际应用中，应该根据实际场景和需求综合评估和选择不同的方式，以提高应用程序的并发处理能力和稳定性。

收录于

Spring Boot框架面试专题（初级-中级）

标签

#面试 #java #spring #spring boot #职场和发展

C#上位机案例：西门子S7协议通信+实时曲线显示（WinForm+ZedGraph）创建/// PLC数据模型（对应DB1块）/// 采集时间（用于曲线的X轴）set;/// 温度值（℃）set;/// 压力值（MPa）set;/// PLC通信状态set;西门子S7协议通信和实时曲线显示，也是工控现场最常见的场景之一。整个开发过程的关键不在于“写出代码”，而在于“写出符合工控场景的稳定代码”——比如解耦通信逻辑与界面逻辑、处理跨线程问题、限制数据点数量、释放资源等。新手在学习时，建议先跟着步骤搭建好环境，跑通基础功能，再逐步尝试进阶优化。需要注意的是，工控上位机的核心是。阅读详情

SpringBoot框架面试专题（初级-中级）-第六节

相关推荐