标签 spring 下的文章

2024-09-03

在Spring Boot中，日志记录是一个重要的部分。以下是一些常见的日志记录技巧和最佳实践。

使用Spring Boot默认日志框架Logback。

Spring Boot内置了Logback作为默认日志框架，你无需进行任何配置即可开始使用。




import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class MyController {
    private static final Logger logger = LoggerFactory.getLogger(MyController.class);
 
    public String index() {
        logger.info("Index method called");
        return "index";
    }
}

配置日志级别

你可以在application.properties或application.yml文件中配置日志级别。




# application.properties
logging.level.root=WARN
logging.level.org.springframework.web=DEBUG
logging.level.com.example.demo=INFO

使用自定义日志配置

如果你需要使用自定义日志配置，你可以在src/main/resources目录下添加一个logback-spring.xml文件。




<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <root level="info">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

异步日志

对于高并发的应用，同步日志会影响性能。可以使用异步日志。




<configuration>
    <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="CONSOLE" />
    </appender>
 
    <root level="info">
        <appender-ref ref="ASYNC" />
    </root>
</configuration>

日志文件滚动

可以配置日志文件的滚动策略。




<configuration>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logFile.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <root level="info">
        <appender-ref ref="FILE" />
    </root>
</configuration>

使用Logstash索引日志

可以配置Logback以将日志发送到Logstash。




<configuration>
    <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <destination>localhost:4560</destination>
        <encoder class="net.logstash.logback.encoder.LogstashEncoder" />
    </appender>
 
    <root level="info

- 阅读更多 -

SpringMVC的视图

System

2024-09-03

所有,java

在Spring MVC中，视图是一个抽象的接口，它表示被渲染的数据结果。Spring MVC提供了多种视图实现，例如JSP、Velocity、Freemarker等。

以下是一个简单的示例，展示了如何配置Spring MVC以及如何使用内置的JSP视图。

在Spring的配置文件中配置视图解析器：




<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
 
    <!-- 启用注解扫描 -->
    <context:component-scan base-package="com.example.controller" />
 
    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>
 
</beans>

创建一个控制器，返回一个视图名称：




package com.example.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.servlet.ModelAndView;
 
@Controller
public class ExampleController {
 
    @GetMapping("/example")
    public ModelAndView showExample() {
        ModelAndView mav = new ModelAndView();
        mav.addObject("message", "Hello, Spring MVC!");
        mav.setViewName("example"); // 对应 /WEB-INF/views/example.jsp
        return mav;
    }
}

在/WEB-INF/views/目录下创建一个JSP文件example.jsp：




<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Example Page</title>
</head>
<body>
    <h1>${message}</h1>
</body>
</html>

当你访问/example路径时，Spring MVC将会处理请求，并将模型属性message传递给名为example的JSP视图，最终渲染出响应的HTML页面。

- 阅读更多 -

K8S 部署 SpringBoot 项目(一篇够用)

System

2024-09-03

所有,java

要在Kubernetes上部署Spring Boot项目，你需要创建一个Docker镜像，并定义Kubernetes部署配置。以下是一个简化的步骤和示例配置：

创建Dockerfile:




FROM openjdk:8-jdk-alpine
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

构建Docker镜像:




docker build -t my-spring-boot-app .

推送镜像到镜像仓库:




docker tag my-spring-boot-app my-repo/my-spring-boot-app:1.0.0
docker push my-repo/my-spring-boot-app:1.0.0

创建Kubernetes部署配置 (my-spring-boot-app.yaml):




apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-spring-boot-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-spring-boot-app
  template:
    metadata:
      labels:
        app: my-spring-boot-app
    spec:
      containers:
      - name: my-spring-boot-app
        image: my-repo/my-spring-boot-app:1.0.0
        ports:
        - containerPort: 8080

创建Service以暴露应用 (my-spring-boot-app-service.yaml):




apiVersion: v1
kind: Service
metadata:
  name: my-spring-boot-app-service
spec:
  selector:
    app: my-spring-boot-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

应用配置到Kubernetes:




kubectl apply -f my-spring-boot-app.yaml
kubectl apply -f my-spring-boot-app-service.yaml

以上步骤会创建一个部署，确保有足够的副本运行你的Spring Boot应用，并通过服务暴露它，类型为LoadBalancer允许从外部访问应用。

确保你的Kubernetes集群是运行的，并且kubectl配置正确指向它。此外，替换my-repo/my-spring-boot-app:1.0.0为你的实际镜像路径。

- 阅读更多 -

Spring Cloud源码分析Zuul：核心过滤器

System

2024-09-03

所有,java

在Spring Cloud中，Zuul是一个非常重要的组件，用于提供服务路由、过滤等功能。其核心过滤器是Zuul的核心，下面我们将对其进行源码分析。

我们以PreDecorationFilter为例，来看看Zuul的核心过滤器是如何工作的。




public class PreDecorationFilter extends ZuulFilter {
 
    private static final int FILTER_ORDER = 5;
    private static final boolean SHOULD_FILTER = true;
 
    @Override
    public String filterType() {
        return "pre";
    }
 
    @Override
    public int filterOrder() {
        return FILTER_ORDER;
    }
 
    @Override
    public boolean shouldFilter() {
        return SHOULD_FILTER;
    }
 
    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
 
        // 获取路由服务ID
        String serviceId = request.getParameter("serviceId");
        if (serviceId == null) {
            serviceId = request.getHeader("serviceId");
        }
        if (serviceId == null) {
            serviceId = request.getRequestURI();
            if (serviceId != null) {
                serviceId = serviceId.substring(1);
                int index = serviceId.indexOf("/");
                if (index > 0) {
                    serviceId = serviceId.substring(0, index);
                }
            }
        }
 
        // 如果serviceId不为空，则设置路由
        if (serviceId != null) {
            ctx.set("serviceId", serviceId);
            // 设置代理的服务地址
            RibbonRoutingFilter.RibbonCommandContext commandContext = (RibbonRoutingFilter.RibbonCommandContext) ctx.get("ribbonCommandContext");
            if (commandContext != null) {
                ctx.setRouteHost(commandContext.getServer());
            }
        }
 
        return null;
    }
}

在这个例子中，我们定义了一个PreDecorationFilter类，它继承了ZuulFilter类。在run方法中，我们通过请求上下文获取了请求的参数或者头信息来确定需要路由的服务ID，并将其设置到请求上下文中。如果服务ID存在，我们还会设置代理的服务地址。这个过滤器展示了如何在请求处理的早期阶段对请求进行修改或者重定向。

- 阅读更多 -

SpringBoot学习笔记（九：MongoDB ）

System

2024-09-03

所有,数据库




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
 
import java.util.List;
 
@Service
public class UserService {
 
    @Autowired
    private MongoTemplate mongoTemplate;
 
    public void createUser(User user) {
        mongoTemplate.save(user, "users");
    }
 
    public List<User> getAllUsers() {
        return mongoTemplate.findAll(User.class, "users");
    }
 
    public User getUser(String id) {
        return mongoTemplate.findById(id, User.class, "users");
    }
 
    public void updateUser(String id, User user) {
        Query query = new Query(Criteria.where("id").is(id));
        Update update = new Update().set("name", user.getName()).set("age", user.getAge());
        mongoTemplate.updateFirst(query, update, User.class, "users");
    }
 
    public void deleteUser(String id) {
        Query query = new Query(Criteria.where("id").is(id));
        mongoTemplate.remove(query, User.class, "users");
    }
}

这个代码示例展示了如何使用Spring Data MongoDB来执行基本的MongoDB操作，包括创建、读取、更新和删除。这里的UserService类使用了自动装配来注入MongoTemplate，然后提供了五个方法来处理用户实体的不同操作。这个例子简洁明了，并且使用了Spring Boot的推荐实践。

System

2024-09-03

所有,java




import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.feign.FeignDecorators;
import feign.Feign;
import feign.Param;
import feign.RequestLine;
 
public class Resilience4JFeignExample {
 
    public interface HelloService {
        @RequestLine("GET /hello?name={name}")
        String hello(@Param("name") String name);
    }
 
    public static void main(String[] args) {
        // 创建断路器
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .waitDurationInOpenState(1000)
            .ringBufferSizeInHalfOpenState(3)
            .ringBufferSizeInClosedState(3)
            .build();
        CircuitBreaker circuitBreaker = CircuitBreaker.of("backendName", config);
 
        // 使用断路器装饰Feign客户端
        HelloService helloService = FeignDecorators.builder(HelloService.class)
            .withCircuitBreaker(circuitBreaker)
            .build();
 
        // 使用Feign客户端调用服务
        String result = helloService.hello("World");
        System.out.println(result);
    }
}

这个代码示例展示了如何使用Resilience4J对Feign客户端进行封装，并应用断路器模式。首先，我们定义了一个简单的Feign接口HelloService，用于定义远程服务调用的规范。然后，我们创建了一个断路器实例，并使用FeignDecorators.builder将其应用到HelloService接口上，构建出具备断路器功能的Feign客户端。最后，我们通过这个客户端调用远程服务的方法。这个例子简单而直接，展示了如何将断路器模式集成到服务间调用中。

- 阅读更多 -

微服务 | Springboot整合GateWay+Nacos实现动态路由

System

2024-09-03

所有,java

在Spring Boot中，你可以使用Spring Cloud Gateway结合Spring Cloud Alibaba Nacos实现动态路由。以下是一个简化的示例：

在pom.xml中添加依赖：




<dependencies>
    <!-- Spring Cloud Gateway -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <!-- Spring Cloud Alibaba Nacos Discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!-- Spring Cloud Alibaba Nacos Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
</dependencies>

配置application.yml：




spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # Nacos Server 地址
    gateway:
      discovery:
        locator:
          enabled: true # 开启基于服务发现的路由
      routes:
        - id: user-service
          # 使用服务发现路由，gateway会去nacos拉取服务列表，并动态更新路由
          uri: lb://user-service
          predicates:
            - Path=/user/**

启动类添加注解：




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

这样配置后，Spring Cloud Gateway会结合Nacos服务注册中心，动态地根据服务ID（如user-service）创建路由。当新的服务实例注册到Nacos时，Gateway会自动添加新的路由；当服务实例下线或删除时，Gateway会自动移除对应的路由。这样，你就可以通过Nacos管理你的服务路由，实现动态路由。

- 阅读更多 -

Spring Cloud Gateway 网关跨域问题解决

System

2024-09-03

所有,java

在Spring Cloud Gateway中解决跨域问题，可以通过定义一个全局的过滤器来实现。以下是一个简单的示例代码：




import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
 
@Component
public class CorsGlobalFilter implements GlobalFilter, Ordered {
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        HttpHeaders headers = exchange.getResponse().getHeaders();
        headers.set("Access-Control-Allow-Origin", "*"); // 允许所有源
        headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
        headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
        if (exchange.getRequest().getMethod() == HttpMethod.OPTIONS) {
            response.setStatusCode(HttpStatus.OK);
            return Mono.empty();
        }
        return chain.filter(exchange);
    }
 
    @Override
    public int getOrder() {
        // 确保此过滤器在其他过滤器之前运行
        return -1;
    }
}

这段代码定义了一个全局过滤器CorsGlobalFilter，它实现了GlobalFilter接口，并在filter方法中设置了响应头来允许跨域资源共享。getOrder方法返回的负数确保了这个过滤器会在请求处理之前运行。在实际部署时，为了安全考虑，建议不要使用*作为Access-Control-Allow-Origin的值，而是指定允许的域。

System

2024-09-03

所有,java

由于这本书的内容较为全面且涉及到的技术较新（2023年），并且涉及到IDEA的具体版本，因此无法提供精确的代码实例。但我可以提供一个概括的解决方案和一些关键代码片段。

Spring MVC 框架的扩展通常指的是集成其他技术，如数据库操作、事务管理等。SSM框架（Spring MVC + Spring + MyBatis）整合是指将Spring MVC、Spring和MyBatis这三个框架整合在一起，实现Web层、业务层和数据访问层的分离。

以下是整合SSM框架的关键配置和代码片段：

web.xml配置（Spring MVC和Spring的监听器和Servlet）：




<!-- Spring MVC 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-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
 
<!-- Spring Application Context -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Spring MVC配置文件（spring-mvc.xml）：




<!-- 配置Controller扫描路径 -->
<context:component-scan base-package="com.example.controller" />
 
<!-- 配置视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/" />
    <property name="suffix" value=".jsp" />
</bean>

Spring配置文件（applicationContext.xml）：




<!-- 配置组件扫描，排除Controller -->
<context:component-scan base-package="com.example">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
</context:component-scan>
 
<!-- 配置数据源、事务管理器、事务代理等 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <!-- 数据源配置 -->
</bean>
 
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <!-- MyBatis配置 -->
</bean>
 
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper" />
</bean>
 
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>
 
<!-- 配置事务通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!-- 事务属性定义 -->
</tx:advice>
 
<!-- 应用事务通知 -->
<aop:config>
    <aop:pointcut id="serviceOperation" expression="execution(* com.example.service.*.*(..))" />

- 阅读更多 -

SpringBoot集成日志框架

System

2024-09-03

所有,java

Spring Boot整合日志框架的方法有很多种，以下是一些常见的方法：

使用Spring Boot默认的日志框架Logback

Spring Boot使用Logback作为默认日志框架，所以我们只需要在application.properties或application.yml中配置相应的日志级别、路径等属性即可。

例如，在application.properties中配置：




logging.level.root=WARN
logging.file.name=myapp.log

使用Log4j

如果你想使用Log4j，你需要先排除Logback，然后添加Log4j依赖。

在Maven中排除Logback依赖，并添加Log4j依赖：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-logging</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

然后，在src/main/resources目录下添加log4j2.xml配置文件。

使用SLF4J配合其他日志实现

SLF4J(Simple Logging Facade for Java)是一个Java日志门面库，它本身不提供日志实现，而是允许你在后台选择一个日志框架。

在Maven中添加依赖：




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

然后，在application.properties或application.yml中配置所选日志实现。

以上就是Spring Boot整合日志框架的常见方法。

- 阅读更多 -