1. 首页
  2. 分类
  3. java
Spring Boot 获取 Bean 的 3 种方式！还有谁不会？
System
2024-09-03
所有,java

在Spring Boot中，获取Bean的方式主要有以下三种：

  1. 使用@Autowired注解自动装配：



@Autowired
private YourBeanClass yourBean;
  1. 使用ApplicationContext获取：



@Autowired
private ApplicationContext context;
 
public YourBeanClass getYourBean() {
    return context.getBean(YourBeanClass.class);
}
  1. 使用@Bean注解的方法直接调用：



@Configuration
public class YourConfig {
 
    @Bean
    public YourBeanClass yourBean() {
        return new YourBeanClass();
    }
}
 
public class YourClass {
    @Autowired
    private YourConfig yourConfig;
 
    public void someMethod() {
        YourBeanClass yourBean = yourConfig.yourBean();
        // 使用 yourBean
    }
}

以上三种方式是在Spring框架中获取Bean的常用方法。

- 阅读更多 -
如何仿写简易tomcat 实现思路+代码详细讲解
System
2024-09-03
所有,java

Tomcat实现的核心是Servlet容器，它负责处理客户端请求并返回响应。以下是一个简易版本的Tomcat实现的核心思路和代码示例：

  1. 创建一个基础的Servlet处理类：



public class SimpleServletProcessor {
    public void process(Socket clientSocket) throws IOException {
        InputStream inputStream = clientSocket.getInputStream();
        OutputStream outputStream = clientSocket.getOutputStream();
 
        // 读取HTTP请求
        String httpRequest = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
        System.out.println("Received HTTP Request: " + httpRequest);
 
        // 构造HTTP响应
        String httpResponse = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n" +
                              "<html><body><h1>Hello, World!</h1></body></html>";
        outputStream.write(httpResponse.getBytes(StandardCharsets.UTF_8));
 
        // 关闭资源
        clientSocket.close();
    }
}
  1. 创建一个简易的Server类，用于监听端口和接受连接：



public class SimpleHttpServer {
    private ServerSocket serverSocket;
 
    public SimpleHttpServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        System.out.println("Server started on port " + port);
    }
 
    public void start() throws IOException {
        while (true) {
            Socket clientSocket = serverSocket.accept();
            new Thread(() -> {
                try {
                    new SimpleServletProcessor().process(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
 
    public static void main(String[] args) throws IOException {
        SimpleHttpServer server = new SimpleHttpServer(8080);
        server.start();
    }
}

这个简易版本的Tomcat仅用于演示Servlet容器的基本原理，并不支持多线程处理请求、高级特性（如JSP支持、安全机制等）以及性能优化。在实际应用中，Tomcat的实现会更加复杂，包含很多的错误处理、性能优化和高级特性。

- 阅读更多 -
Linux实战-tomcat操作
System
2024-09-03
所有,java

在Linux环境下操作Tomcat，通常涉及到以下几个操作：

  1. 安装Tomcat
  2. 启动Tomcat
  3. 关闭Tomcat
  4. 监控Tomcat状态
  5. 配置Tomcat

以下是基于这些操作的简单示例：

  1. 安装Tomcat

首先，确保你有Java环境，因为Tomcat是一个Java servlet容器。




# 安装Java
sudo apt-get install default-jdk
 
# 验证Java安装
java -version
 
# 创建Tomcat用户
sudo groupadd tomcat
sudo useradd -s /bin/false -g tomcat -d /opt/tomcat tomcat
 
# 下载Tomcat
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz
 
# 解压Tomcat
sudo tar xzf apache-tomcat-*tar.gz -C /opt/
 
# 更改目录权限
sudo chgrp -R tomcat /opt/apache-tomcat-*
sudo chmod -R g+r conf
sudo chmod g+x conf
sudo chown -R tomcat webapps/ work/ temp/ logs/
 
# 创建软链接
sudo ln -s /opt/apache-tomcat-* /opt/tomcat
 
# 设置环境变量
export CATALINA_HOME=/opt/tomcat
export PATH=$CATALINA_HOME/bin:$PATH
  1. 启动Tomcat



# 切换到Tomcat用户
sudo su - tomcat
 
# 启动Tomcat
$CATALINA_HOME/bin/startup.sh
  1. 关闭Tomcat



# 切换到Tomcat用户
sudo su - tomcat
 
# 关闭Tomcat
$CATALINA_HOME/bin/shutdown.sh
  1. 监控Tomcat状态



# 使用ps命令查看Tomcat进程
ps -ef | grep tomcat
 
# 检查Tomcat日志
cat $CATALINA_HOME/logs/catalina.out
  1. 配置Tomcat

编辑 $CATALINA_HOME/conf/server.xml 来配置Tomcat，例如设置端口号、配置虚拟主机等。

这些是基本的Tomcat操作，具体的操作可能会根据你的需求和环境有所不同。

- 阅读更多 -
Spring Cloud Gateway如何匹配某路径并进行路由转发
System
2024-09-03
所有,java

在Spring Cloud Gateway中，你可以通过定义路由规则来匹配特定的路径并进行路由转发。以下是一个简单的例子，展示如何配置Spring Cloud Gateway以将匹配特定路径的请求转发到一个服务。

  1. 首先，在application.yml配置文件中定义你的路由规则，或者如果你使用的是application.properties，则相应地定义。



spring:
  cloud:
    gateway:
      routes:
        - id: my_route
          uri: http://myservice
          predicates:
            - Path=/mypath/**

这个配置定义了一个路由，其中id是路由的唯一标识符，uri是目标服务的地址，predicates定义了路由的匹配规则，这里是匹配所有以/mypath/开头的路径。

  1. 接下来，请求/mypath/下的任何路径（例如/mypath/foo或/mypath/bar）都会被转发到http://myservice。

确保你的Spring Cloud Gateway服务能够访问目标服务的地址。

以上就是一个使用Spring Cloud Gateway进行路由配置的基本例子。

- 阅读更多 -
linux服务器tomcat日志中文出现问号乱码
System
2024-09-03
所有,java

乱码问题通常由于字符编码不一致导致。以下是解决Linux服务器上Tomcat日志中中文出现问号乱码的步骤：

  1. 检查系统字符编码：

    执行 locale 命令查看当前系统字符编码，确保其支持中文（如UTF-8）。

  2. 配置Tomcat字符编码：

    • 修改Tomcat的catalina.sh（或catalina.bat）启动脚本，添加或修改JAVA_OPTS环境变量，如下：

      


JAVA_OPTS="-Dfile.encoding=UTF-8"
    • 修改Tomcat的日志配置文件（如logging.properties），确保编码设置为UTF-8。

  3. 重启Tomcat服务：

    执行 shutdown.sh 关闭Tomcat，再执行 startup.sh 启动Tomcat。

  4. 检查结果：

    重新查看Tomcat日志文件，中文乱码问题应该得到解决。

如果以上步骤不能解决问题，可能需要检查客户端查看日志的工具是否支持中文显示，或者检查是否有其他中间件或应用程序影响了字符编码的正常显示。

- 阅读更多 -
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 AddRequestHeaderFilter implements GlobalFilter, Ordered {
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        HttpHeaders headers = exchange.getRequest().getHeaders();
        // 添加自定义的请求头
        headers.add("Custom-Header", "custom-value");
        return chain.filter(exchange);
    }
 
    @Override
    public int getOrder() {
        // 确保此过滤器在其他过滤器之前运行
        return -1;
    }
}

这段代码定义了一个全局过滤器AddRequestHeaderFilter，它实现了GlobalFilter接口并添加了一个名为Custom-Header的请求头，其值为custom-value。通过设置getOrder()方法返回的整数值为-1，确保了此过滤器将在其他所有过滤器之前运行。

当请求通过Gateway时，这个过滤器会自动被应用，添加的请求头将会包含在发往下游服务的请求中。

- 阅读更多 -
SpringCloud 负载均衡 spring-cloud-starter-loadbalancer
System
2024-09-03
所有,java

Spring Cloud LoadBalancer是Spring Cloud的一个子项目，它提供了一些客户端负载均衡器的实现，用于在使用Spring Cloud进行服务到服务的通信时，实现客户端的负载均衡。

以下是使用Spring Cloud LoadBalancer的一个简单示例：

  1. 首先，在你的Spring Cloud项目中的pom.xml文件中添加依赖：



<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
  1. 在你的应用程序中，你可以使用@LoadBalanced注解来标记RestTemplate，使其支持负载均衡。



@Configuration
public class Config {
 
    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
  1. 使用RestTemplate发起服务间调用时，URL可以是服务名称，LoadBalancer会自动根据服务名查询服务实例并进行负载均衡。



@Service
public class MyService {
 
    @Autowired
    private RestTemplate restTemplate;
 
    public String callService(String serviceName) {
        return restTemplate.getForObject("http://" + serviceName + "/some-endpoint", String.class);
    }
}

在上述代码中，callService方法通过服务名称调用其他服务的接口，LoadBalancer会根据服务名自动查找可用的服务实例并进行负载均衡的请求分发。

注意：Spring Cloud LoadBalancer依赖于Spring Cloud Netflix，因此你需要确保Spring Cloud Netflix依赖也在你的项目中。如果你的项目中没有使用Spring Cloud Netflix的其他组件，你可能还需要添加对应的依赖。

- 阅读更多 -
tomcat跨域问题CORS踩坑点
System
2024-09-03
所有,java

解决Tomcat跨域问题的CORS配置：

  1. 配置web.xml：



<filter>
    <filter-name>CORS</filter-name>
    <filter-class>com.thetransactioncompany.cors.CORSFilter</filter-class>
    <init-param>
        <param-name>cors.allowOrigin</param-name>
        <param-value>*</param-value>
    </init-param>
    <init-param>
        <param-name>cors.supportedMethods</param-name>
        <param-value>GET, POST, HEAD</param-value>
    </init-param>
    <init-param>
        <param-name>cors.supportedHeaders</param-name>
        <param-value>Accept, Origin, X-Requested-With, Content-Type, Last-Modified</param-value>
    </init-param>
    <init-param>
        <param-name>cors.exposedHeaders</param-name>
        <param-value>Set-Cookie</param-value>
    </init-param>
    <init-param>
        <param-name>cors.supportsCredentials</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CORS</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
  1. 确保你的Tomcat版本支持CORS过滤器，如果不支持，需要升级Tomcat或者使用其他CORS实现。
  2. 如果你使用的是Tomcat 8.5或更高版本，可以使用内置的CORS支持：



<filter>
    <filter-name>CORS</filter-name>
    <filter-class>org.apache.catalina.filters.CorsFilter</filter-class>
    <init-param>
        <param-name>cors.allowed.origins</param-name>
        <param-value>*</param-value>
    </init-param>
    <init-param>
        <param-name>cors.allowed.methods</param-name>
        <param-value>GET,POST,HEAD,OPTIONS</param-value>
    </init-param>
    <init-param>
        <param-name>cors.allowed.headers</param-name>
        <param-value>Content-Type,X-Requested-With,accept,Origin,Access-Control-Request-Method,Access-Control-Request-Headers</param-value>
    </init-param>
    <init-param>
        <param-name>cors.exposed.headers</param-name>
        <param-value>Access-Control-Allow-Origin,Access-Control-Allow-Credentials</param-value>
    </init-param>
    <init-param>
        <param-name>cors.support.credentials</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CORS</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
  1. 如果你需要进一步的动态配置，可以通过编程方式设置CORS策略。
  2. 确保你的Tomcat和应用服务器的安全配置允许跨域请求。
  3. 测试你的配置，确保它按预期工作。

注意：在生产环境中，不建议使用cors.allowOrigin设置为*

- 阅读更多 -
SpringBoot统一功能
System
2024-09-03
所有,java

SpringBoot统一功能指的是在SpringBoot应用中实现一些通用的功能，比如全局异常处理、全局日志记录、全局数据格式化等。

以下是一个简单的SpringBoot项目，集成了全局异常处理、全局日志记录和全局数据格式化的例子：




import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.format.FormatterRegistry;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
 
@SpringBootApplication
public class Application {
 
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
 
    @ControllerAdvice
    class GlobalExceptionHandler {
 
        @ExceptionHandler(Exception.class)
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
        public String handleGlobalException(Exception e) {
            // 日志记录异常信息
            log.error("Exception caught: ", e);
            return "error/error";
        }
    }
 
    @org.springframework.context.annotation.Configuration
    static class GlobalConfiguration implements WebMvcConfigurer {
 
        @Override
        public void addFormatters(FormatterRegistry registry) {
            // 添加全局数据格式化
            registry.addFormatter(new DateTimeFormatter());
        }
    }
 
    static class DateTimeFormatter implements Formatter<LocalDateTime> {
 
        private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
 
        @Override
        public String print(LocalDateTime object, Locale locale) {
            return DATE_TIME_FORMATTER.format(object);
        }
 
        @Override
        public LocalDateTime parse(String text, Locale locale) {
            return LocalDateTime.parse(text, DATE_TIME_FORMATTER);
        }
    }
 
    private static final Logger log = LoggerFactory.getLogger(Application.class);
}

在这个例子中，GlobalExceptionHandler 类用于处理全局异常，并通过日志记录异常信息。GlobalConfiguration 类实现了 WebMvcConfigurer 接口，用于添加全局数据格式化。DateTimeFormatter 类实现了 Formatter 接口，用于将 LocalDateTime 对象格式化为字符串，并将字符串解析为 LocalDateTime 对象。

这个例子展示了如何在SpringBoot应用中添加全局

- 阅读更多 -
Tomcat10使用pfx证书配置https(windows)
System
2024-09-03
所有,java

在Windows上为Tomcat 10配置HTTPS，你需要一个PFX格式的证书文件和对应的密钥。以下是配置步骤和示例配置：

  1. 将PFX证书文件放置到Tomcat的conf目录下。
  2. 修改Tomcat的server.xml文件，在<Connector>标签中配置使用PFX证书，并指定密钥库和相关属性。

打开conf/server.xml文件，找到类似以下的<Connector>配置，并根据你的PFX证书文件名和密码进行修改：




<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
           maxThreads="150" SSLEnabled="true">
    <UpgradeProtocol className="org.apache.coyote.http2.Http2Protocol" />
    <SSLHostConfig>
        <Certificate certificateKeystoreFile="conf/yourcertificate.pfx"
                     certificateKeystoreType="PKCS12"
                     certificateKeystorePassword="yourpfxpassword" />
    </SSLHostConfig>
</Connector>

确保certificateKeystoreFile指向你的PFX文件的正确路径，certificateKeystorePassword是你的PFX密码。

  1. 重启Tomcat服务器以使配置生效。

确保你的PFX证书是由一个信任的CA签发的，并且它是有效的，否则用户可能会看到一个警告页面，表明连接不是私密的。

请注意，如果你的PFX证书文件不在Tomcat的conf目录下，你需要指定完整的路径。同时，确保Tomcat有足够的权限去读取你的证书文件。

- 阅读更多 -
Copyright © 2025 Tech Blog
All Right Reserved | 京ICP备19053165号