标签 spring 下的文章

spring boot 2.x静态资源会被HandlerInterceptor拦截的因和解决方法

2024-08-29

Spring Boot 2.x中静态资源被HandlerInterceptor拦截的问题通常是由于拦截器配置不正确导致的。HandlerInterceptor是Spring MVC中用于处理请求拦截的机制，如果配置不当，可能会拦截到静态资源的请求。

原因: 如果拦截器配置为拦截所有请求，例如使用/**作为映射路径，它会捕获静态资源的请求，导致这些资源无法正常访问。

解决方法:

配置拦截器时，正确设定需要拦截的路径，不要包括静态资源的路径。例如，只拦截/api/**的请求，而不拦截/static/**或者/public/**。




@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(yourInterceptor)
        .addPathPatterns("/api/**")
        .excludePathPatterns("/static/**", "/public/**", "/css/**", "/js/**", "/images/**");
}

如果你需要对所有请求进行拦截，但要排除静态资源，可以在拦截器中检查请求是否为静态资源，并返回NO\_INTERCEPTOR。




@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    String uri = request.getRequestURI();
    if (uri.startsWith("/static/") || uri.startsWith("/public/") || uri.startsWith("/css/") || uri.startsWith("/js/") || uri.startsWith("/images/")) {
        return true; // 不拦截静态资源
    }
    // 执行其他拦截逻辑
    return false;
}

确保静态资源的路径配置在Spring Boot的application.properties或application.yml中，Spring Boot会自动将这些路径映射到对应的文件夹。




# application.properties
spring.resources.static-locations=classpath:/static/,classpath:/public/,file:${spring.servlet.multipart.location}

确保以上步骤后，静态资源应该能够正常访问，而自定义的拦截器只会拦截到需要拦截的请求路径。

- 阅读更多 -

SpringBoot中pom.xml配置详解第三章

System

2024-08-29

所有,java

在Spring Boot中，pom.xml文件是Maven项目的核心配置文件，它包含了项目的依赖、插件和构建规则等信息。以下是pom.xml中常见配置的简要说明：

modelVersion：指定了POM模型版本，通常是4.0.0。
groupId：定义了项目属于哪个组织或团队的标识符。
artifactId：定义了项目的唯一标识符，通常是项目名。
version：定义了项目的版本号。
properties：定义了可重用的属性，用于设置版本号等值。
dependencies：列出了项目的所有依赖。每个依赖可以包括groupId，artifactId和version来指定。
dependencyManagement：用于管理项目的依赖版本，确保所有子项目中的依赖版本一致。
build：包含了项目构建时的配置，比如插件配置、资源配置等。
parent：定义了项目的父POM，用于继承父项目的配置。
repositories：定义了项目的仓库，用于下载依赖。
pluginRepositories：定义了插件的仓库，用于下载Maven插件。
reporting：配置了项目报告的相关设置。

以下是一个简单的pom.xml配置示例：




<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.example</groupId>
    <artifactId>my-spring-boot-app</artifactId>
    <version>1.0-SNAPSHOT</version>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/>
    </parent>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

这个示例配置了Spring Boot项目的基本POM。它指定了项目的版本和属性，引入了Spring Boot的起步依赖spring-boot-starter-web，以便开发Web应用程序，并配置了Spring Boot的Maven插件。

- 阅读更多 -

Spring Boot整合Redis的哨兵模式

System

2024-08-29

所有,redis

在Spring Boot中整合Redis的哨兵模式，你需要在application.properties或application.yml中配置Redis哨兵的相关信息。

以下是使用application.yml配置的示例：




spring:
  redis:
    sentinel:
      master: mymaster # 主服务器的名字
      nodes:
        - sentinel-host1:26379
        - sentinel-host2:26379
        - sentinel-host3:26379

在Spring Boot的配置类中，你可以使用@Autowired来注入RedisTemplate或StringRedisTemplate，这样就可以使用Redis哨兵模式进行操作了。




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
 
@Configuration
public class RedisConfig {
 
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;
 
    @Bean
    public RedisTemplate<Object, Object> redisTemplate() {
        final RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
 
    @Bean
    public StringRedisTemplate stringRedisTemplate() {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

在你的服务中，你可以使用RedisTemplate或StringRedisTemplate来操作Redis：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
 
@Service
public class RedisService {
 
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
 
    public void setKeyValue(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }
 
    public String getValueByKey(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
}

确保你的项目中已经添加了Spring Data Redis和Jedis的依赖：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

以上代码提供了一个基本的示例，展示了如何在Spring Boot应用程序中配置和使用Redis哨兵模式。

- 阅读更多 -

springcloud-服务治理

System

2024-08-29

所有,java

在Spring Cloud中，服务治理通常是通过Spring Cloud Netflix的Eureka来实现的。以下是一个简单的例子，展示如何使用Eureka实现服务治理。

添加依赖到你的pom.xml：




<dependencies>
    <!-- Eureka Server -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

配置Eureka Server：




@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

在application.properties或application.yml中配置Eureka Server：




server:
  port: 8761
 
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

配置Eureka Client：

在客户端的application.properties或application.yml中，配置Eureka Server的地址：




eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

在客户端的Spring Boot应用中，使用@EnableDiscoveryClient注解来启用服务发现：




@EnableDiscoveryClient
@SpringBootApplication
public class MyServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyServiceApplication.class, args);
    }
}

通过以上步骤，你就可以在Spring Cloud应用中使用Eureka实现服务治理了。Eureka Server负责服务的注册与发现，而Eureka Client则用来将服务注册到Eureka Server并从Eureka Server获取服务列表。

- 阅读更多 -

Spring Boot应用启动时自动执行代码的五种方式

System

2024-08-29

所有,java

在Spring Boot应用中，有多种方式可以在启动时自动执行代码：

使用CommandLineRunner或ApplicationRunner接口。
使用@PostConstruct注解标注的方法。
使用ApplicationListener监听ContextRefreshedEvent事件。
使用@Bean注解定义的方法。
使用Spring的@Scheduled注解定义定时任务。

以下是每种方法的示例代码：

使用CommandLineRunner：




@Component
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) {
        // 在这里编写启动时需要执行的代码
    }
}

使用ApplicationRunner：




@Component
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) {
        // 在这里编写启动时需要执行的代码
    }
}

使用@PostConstruct：




@Component
public class MyBean {
    @PostConstruct
    public void init() {
        // 在这里编写启动时需要执行的代码
    }
}

使用ApplicationListener：




@Component
public class MyApplicationListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 检查应用程序上下文是否已完全加载
        if (event.getApplicationContext().getParent() == null) {
            // 在这里编写启动时需要执行的代码
        }
    }
}

使用@Bean注解定义方法：




@Configuration
public class MyConfiguration {
    @Bean(initMethod = "init")
    public MyBean myBean() {
        return new MyBean();
    }
}
 
public class MyBean {
    public void init() {
        // 在这里编写启动时需要执行的代码
    }
}

使用@Scheduled定时任务：




@Component
public class MyScheduledTask {
    @Scheduled(fixedRate = 1000)
    public void executeTask() {
        // 在这里编写启动时需要执行的代码
    }
}

在这些方法中，你可以编写你需要在Spring Boot应用启动时自动执行的代码。通常，CommandLineRunner和ApplicationRunner用于处理命令行参数，而@PostConstruct、ApplicationListener<ContextRefreshedEvent>和@Bean注解的initMethod更侧重于初始化逻辑，@Scheduled用于定时任务。根据你的具体需求，选择合适的方法实现你的自动启动代码。

System

2024-08-29

所有,java

在Spring MVC中，你可以使用CommonsMultipartResolver来处理文件上传，或者使用Servlet 3.0引入的<multipart-config>元素配置在控制器方法中处理文件上传。

使用CommonsMultipartResolver

添加依赖库commons-fileupload和commons-io到你的项目中。
在Spring配置文件中配置CommonsMultipartResolver。




<bean id="multipartResolver"
      class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 设置最大上传文件大小 -->
    <property name="maxUploadSize" value="100000"/>
</bean>

在控制器中处理上传的文件。




@Controller
public class FileUploadController {
    @RequestMapping(value = "/upload", method = RequestMethod.POST)
    public String handleFileUpload(@RequestParam("file") MultipartFile file) {
        // 处理上传的文件
        return "success";
    }
}

使用`<multipart-config>`

在web.xml中配置<multipart-config>。




<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
    </init-param>
    <multipart-config>
        <!-- 设置文件存储的临时位置 -->
        <location>/tmp</location>
        <!-- 设置最大上传文件大小 -->
        <max-file-size>100000</max-file-size>
        <max-request-size>100000</max-request-size>
    </multipart-config>
</servlet>

在Spring的servlet-context.xml中配置multipartResolver。




<beans ...>
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.support.StandardServletMultipartResolver"/>
</beans>

在控制器中处理上传的文件，使用@RequestParam注解接收上传的文件。




@Controller
public class FileUploadController {
    @RequestMapping(value = "/upload", method = RequestMethod.POST)
    public String handleFileUpload(@RequestParam("file") MultipartFile file) {
        // 处理上传的文件
        return "success";
    }
}

两种方式都可以处理文件上传，你可以根据实际情况选择使用哪一种。如果你使用的是Servlet 3.0或更高版本的容器，推荐使用<multipart-config>，因为它是标准的方式，而且配置更简单。如果你需要更多的定制化，比如使用特定的上传库，那么可以选择使用CommonsMultipartResolver。

System

2024-08-29

所有,java

在Spring MVC中，你可以通过配置类来定义拦截器，并将其注册到Spring MVC框架中。以下是拦截器的基础配置和高级配置示例。

拦截器基础配置

首先，创建一个实现了HandlerInterceptor接口的拦截器类：




import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class SimpleInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 在请求处理之前进行调用
        return true; // 如果返回false，则停止流程，api不会被调用
    }
 
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        // 请求处理之后进行调用，但是在视图被渲染之前
    }
 
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 在整个请求结束之后调用，也就是在DispatcherServlet渲染了视图执行
    }
}

然后，在Spring MVC配置类中注册这个拦截器：




import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new SimpleInterceptor()).addPathPatterns("/**");
        // 这里可以配置拦截器的路径规则
    }
}

拦截器高级配置

如果你需要根据不同的条件注册不同的拦截器，可以这样做：




@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(new SimpleInterceptor())
        .addPathPatterns("/api/**") // 拦截api路径
        .excludePathPatterns("/api/login"); // 排除登录接口
 
    registry.addInterceptor(new AnotherInterceptor())
        .addPathPatterns("/admin/**"); // 只拦截admin路径
}

在这个例子中，SimpleInterceptor会拦截所有路径为/api/的请求，并排除/api/login接口。另一个拦截器AnotherInterceptor只会拦截路径为/admin/的请求。

- 阅读更多 -

Spring Cloud之API网关（Gateway）

System

2024-08-29

所有,java

Spring Cloud Gateway是Spring Cloud的一个全新项目，该项目是基于Spring 5.0，Spring WebFlux和Project Reactor等技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的API路由管理方式。

以下是一个使用Spring Cloud Gateway作为API网关的简单示例：

在pom.xml中添加依赖：




<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Finchley.SR2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

配置application.yml文件：




spring:
  cloud:
    gateway:
      routes:
        - id: after_route
          uri: http://localhost:8081
          predicates:
            - Path=/api/**
        - id: hystrix_route
          uri: http://localhost:8082
          predicates:
            - Path=/api-hystrix/**
          filters:
            - Hystrix=myCommand

在这个配置中，我们定义了两条路由规则。第一条规则将所有访问/api/**的请求转发到http://localhost:8081。第二条规则将所有访问/api-hystrix/**的请求转发到http://localhost:8082，并使用Hystrix断路器保护。

创建Spring Boot启动类：




@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

这个简单的示例展示了如何使用Spring Cloud Gateway来路由和管理API请求。在实际应用中，你可能需要根据具体需求配置更多的路由规则、过滤器和断路器。

- 阅读更多 -

Spring Boot中的@Async注解详解

System

2024-08-29

所有,java

@Async 是Spring提供的一个用于创建异步任务的注解，它可以使用于方法上，在不阻塞当前线程的情况下执行耗时任务或者调用其他服务。

在Spring Boot中使用@Async注解，你需要做以下几步：

在启动类上添加@EnableAsync注解来启用异步方法执行的功能。
在需要异步执行的方法上添加@Async注解。
确保异步方法的调用者和被调用者之间不形成循环依赖。
异步方法的返回类型必须是Future、CompletableFuture或ListenableFuture类型，以便支持异步回调。

示例代码：




// 启动类
@SpringBootApplication
@EnableAsync // 启用异步支持
public class AsyncApplication {
    public static void main(String[] args) {
        SpringApplication.run(AsyncApplication.class, args);
    }
}
 
// 异步任务的执行服务
@Service
public class AsyncService {
 
    @Async
    public Future<String> executeAsyncTask() {
        // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult<>("异步任务执行完毕");
    }
}
 
// 控制器
@RestController
public class AsyncController {
 
    @Autowired
    private AsyncService asyncService;
 
    @GetMapping("/async")
    public String startAsyncTask() throws ExecutionException, InterruptedException {
        Future<String> future = asyncService.executeAsyncTask();
        return future.get(); // 等待异步任务执行完毕并返回结果
    }
}

在这个例子中，AsyncService 类中的 executeAsyncTask 方法被标记为异步方法，该方法将在不阻塞主线程的情况下执行。AsyncController 的 startAsyncTask 方法调用了异步服务，并通过 Future.get() 方法获取异步执行的结果。

- 阅读更多 -

基于协同过滤推荐算法+springboot+vue的个人摄影作品分享网站

System

2024-08-29

所有,java

由于这是一个完整的项目，我们可以提供一些核心的代码片段或者架构设计来帮助理解。

用户评分计算协同过滤推荐（核心函数）:




def calculate_similarity(user1_ratings, user2_ratings):
    # 计算两用户的相似度
    ...
 
def get_recommendations(user_id, ratings, similarity, n=10):
    # 获取推荐作品
    user_ratings = ratings[user_id]
    all_users = ratings.keys()
    all_users.remove(user_id)
 
    recommendations = []
    for other_user in all_users:
        if other_user != user_id:
            sim = similarity[user_id][other_user]
            if sim > 0:
                for item in ratings[other_user]:
                    if item not in user_ratings:
                        recommendations.append((item, sim * user_ratings.get(item, 0)))
 
    return sorted(recommendations, key=lambda x: -x[1])[:n]

后端Spring Boot控制器（简化版）:




@RestController
@RequestMapping("/api/recommendation")
public class RecommendationController {
 
    @Autowired
    private RecommendationService recommendationService;
 
    @GetMapping("/{userId}")
    public ResponseEntity<?> getRecommendations(@PathVariable("userId") String userId) {
        List<Item> recommendations = recommendationService.getRecommendations(userId);
        return ResponseEntity.ok(recommendations);
    }
}

前端Vue组件（用于展示推荐作品）:




<template>
  <div>
    <div v-for="item in recommendations" :key="item.id">
      {{ item.title }}
    </div>
  </div>
</template>
 
<script>
export default {
  data() {
    return {
      recommendations: []
    };
  },
  created() {
    this.fetchRecommendations();
  },
  methods: {
    fetchRecommendations() {
      const userId = 'user123'; // 示例用户ID
      this.$http.get(`/api/recommendation/${userId}`)
        .then(response => {
          this.recommendations = response.data;
        })
        .catch(error => {
          console.error('Error fetching recommendations:', error);
        });
    }
  }
};
</script>

这些代码片段提供了核心逻辑，展示了如何计算用户推荐、后端如何提供推荐服务以及前端如何展示推荐结果。实际应用中，你需要实现数据库访问、完善的业务逻辑以及错误处理等。

- 阅读更多 -

使用CommonsMultipartResolver

使用<multipart-config>

拦截器基础配置

拦截器高级配置

使用`<multipart-config>`