分类 java 下的文章

2024-08-29

Tomcat 优化可以从多个方面进行，包括调整内存设置、配置连接器（Connector）、调优线程池、配置JVM参数等。以下是一些常见的优化方法和示例：

调整内存设置：
编辑 setenv.sh 或 setenv.bat 文件（如果不存在则创建），设置 CATALINA_OPTS 或 JAVA_OPTS 环境变量来调整JVM内存设置。
```
export CATALINA_OPTS="-Xms512m -Xmx1024m"
```

配置连接器（Connector）：

修改 server.xml 文件中的 Connector 配置，调整如 maxThreads（最大线程数）、minSpareThreads（最小空闲线程数）、acceptCount（接受的连接数）等。




<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           maxThreads="200"
           minSpareThreads="10"
           acceptCount="100" />

调优线程池：

如果使用了Tomcat的线程池，可以通过 executor 标签进行配置。




<Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
         maxThreads="200" minSpareThreads="10" />
 
<Connector executor="tomcatThreadPool"
           port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

配置JVM参数：
在 setenv.sh 或 setenv.bat 文件中设置JVM参数，例如 -XX:+UseParallelGC 来指定垃圾收集器。
```
export CATALINA_OPTS="$CATALINA_OPTS -XX:+UseParallelGC"
```

关闭DNS查询：

修改 server.xml 中的 Connector 配置，添加 enableLookups="false" 以关闭DNS查询，提高处理性能。




<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" enableLookups="false" />

压缩响应数据：

启用gzip压缩可以减少网络传输数据量，提升性能。




<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" compressableMimeType="text/html,text/xml,text/plain,text/css,application/json,application/javascript,application/x-javascript" />

调整连接超时：

修改 server.xml 中的 Connector 配置，调整 connectionTimeout 和 keepAliveTimeout 参数。




<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" keepAliveTimeout="15000" />

配置日志等级：
修改 logging.properties 文件，根据需要调整日志等级。
```
org.apache.catalina.level = INFO
org.apache.tomcat.level = INFO
```
使用APR（Apache Portable Runtime）：
如果在Unix-like系统上安装了AP

- 阅读更多 -

SpringBoot使用maven指定依赖包的版本

System

2024-08-29

所有,java

在Spring Boot项目中使用Maven时，可以在pom.xml文件中统一指定依赖包的版本。这样做可以避免版本冲突和不一致的问题，同时方便后续的维护和升级。

以下是如何在pom.xml中指定版本的示例：




<properties>
    <spring-boot.version>2.3.1.RELEASE</spring-boot.version>
</properties>
 
<dependencies>
    <!-- 指定Spring Boot的版本 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>${spring-boot.version}</version>
    </dependency>
 
    <!-- 其他依赖项 -->
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <!-- 这里也可以指定其他库的版本 -->
    </dependencies>
</dependencyManagement>

在<properties>标签中定义了一个自定义属性spring-boot.version，然后在<dependencies>和<dependencyManagement>中的<version>标签使用这个属性。这样，所有Spring Boot的依赖项和其他可能的依赖项都将使用这个指定的版本。

注意：

使用<dependencyManagement>而不是直接在<dependencies>中指定版本的好处是，子项目可以有选择地覆盖父项目中定义的依赖版本。
当你需要升级整个项目的依赖版本时，只需要在<properties>中更新版本号，所有依赖项都会自动更新。

- 阅读更多 -

Springboot中@FeignClient详解

System

2024-08-29

所有,java

@FeignClient是Spring Cloud提供的一个注解，用于声明一个Feign客户端的接口，以便使用Feign来调用远程服务。

以下是@FeignClient的主要属性：

name: 指定远程服务的名称，必须指定。
url: 直接指定远程服务的URL，不通过服务发现。
serviceId: 已废弃，与name属性等同。
contextId: 如果需要创建多个Feign客户端，可以通过contextId来区分。
decode404: 是否将404响应转换为空对象，而不是抛出异常，默认false。
configuration: 指定Feign的配置类，可以自定义Feign的Encoder、Decoder和Contract。
fallback: 指定一个fallback类，当服务调用失败时，会调用fallback类中的方法。
path: 指定服务路径，用于当服务的分组功能。

使用示例：




@FeignClient(name = "service-provider", url = "http://localhost:8080", contextId = "remoteService")
public interface RemoteService {
    @GetMapping("/data")
    String getData();
 
    @PostMapping("/submit")
    void submitData(@RequestBody MyData data);
}

在上面的例子中，RemoteService接口定义了两个方法，用于调用远程服务service-provider的/data和/submit接口。通过@FeignClient注解指定了服务名称、URL和上下文ID。

若要使用fallback机制，需要定义一个fallback类：




@Component
public class RemoteServiceFallback implements RemoteService {
    @Override
    public String getData() {
        return "Fallback message";
    }
 
    @Override
    public void submitData(MyData data) {
        // Fallback logic
    }
}

然后在@FeignClient注解中指定fallback类：




@FeignClient(name = "service-provider", url = "http://localhost:8080", contextId = "remoteService", fallback = RemoteServiceFallback.class)
public interface RemoteService {
    // ...
}

这样，当service-provider服务不可用时，就会调用RemoteServiceFallback中的方法。

- 阅读更多 -

Spring Boot：Spring Boot启动原理分析

System

2024-08-29

所有,java

Spring Boot启动的核心流程如下：

通过SpringApplication类的run方法启动Spring Boot应用。
SpringApplication类会创建一个ApplicationContext。
根据配置确定应用的类型，并设置相应的ApplicationContext。
应用配置的监听器会被注册。
通过SpringFactoriesLoader机制加载META-INF/spring.factories文件中的自动配置类。
进行自动配置，并且注册bean定义到ApplicationContext中。
调用所有注册的bean生命周期监听器和应用启动监听器。
启动完成，等待用户请求处理。

以下是一个简化的Spring Boot启动类示例：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication // 标注这是一个Spring Boot应用
public class MySpringBootApplication {
 
    public static void main(String[] args) {
        // 启动Spring Boot应用
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}

在这个示例中，@SpringBootApplication注解是Spring Boot的核心注解，它是一个组合注解，包含了@EnableAutoConfiguration、@ComponentScan和@Configuration。@EnableAutoConfiguration让Spring Boot根据类路径设置、其他注解和application.properties或application.yml文件来自动配置Spring容器。@ComponentScan告诉Spring Let Boot在这个包下扫描@Components、@Services、@Repositories等Bean。

- 阅读更多 -

SpringBoot接收参数的几种常用方式

System

2024-08-29

所有,java

在Spring Boot中，接收参数的常见方式有以下几种：

通过@RequestParam接收查询参数（Query parameter）。
通过@PathVariable接收路径参数（Path variable）。
通过@RequestBody接收请求体（Request body）中的JSON或XML数据，通常用于POST或PUT请求。
通过@ModelAttribute接收表单提交的数据，通常用于POST请求。
通过@RequestHeader接收请求头（Request header）数据。
通过@MatrixVariable接收路径段的矩阵变量（Matrix variable）。

以下是各种方式的示例代码：




// 1. 通过@RequestParam接收查询参数
@GetMapping("/users")
public String getUsersByName(@RequestParam String name) {
    // ...
}
 
// 2. 通过@PathVariable接收路径参数
@GetMapping("/users/{id}")
public String getUserById(@PathVariable Integer id) {
    // ...
}
 
// 3. 通过@RequestBody接收请求体数据
@PostMapping("/users")
public User createUser(@RequestBody User user) {
    // ...
}
 
// 4. 通过@ModelAttribute接收表单数据
@PostMapping("/users")
public String submitForm(@ModelAttribute User user) {
    // ...
}
 
// 5. 通过@RequestHeader接收请求头数据
@GetMapping("/users")
public String getUsersByHeader(@RequestHeader("Authorization") String auth) {
    // ...
}
 
// 6. 通过@MatrixVariable接收矩阵变量
@GetMapping("/cars/{brand}")
public String getCarModels(@PathVariable String brand, @MatrixVariable Map<String, String> matrixVars) {
    // ...
}

注意：@ModelAttribute通常与表单提交配合使用，而@MatrixVariable主要用于REST风格的URL设计，在非REST风格的应用中较少使用。

- 阅读更多 -

详解在Linux中修改Tomcat使用的jdk版本

System

2024-08-29

所有,java

在Linux中修改Tomcat使用的JDK版本，你需要做的是：

确定你想要使用的JDK版本的安装路径。
修改Tomcat的环境配置文件以指向新的JDK路径。

以下是具体步骤和示例：

找到你的JDK路径。假设你已经安装了JDK 11，它可能位于/usr/lib/jvm/jdk-11。
编辑Tomcat的setenv.sh文件（如果不存在，则创建它）。该文件通常位于$CATALINA_HOME/bin目录中。




cd $CATALINA_HOME/bin
nano setenv.sh

如果你使用的是setenv.sh，添加以下内容来设置JAVA\_HOME：




export JAVA_HOME=/usr/lib/jvm/jdk-11
export JRE_HOME=${JAVA_HOME}/jre

如果你使用的是catalina.sh脚本，可以在其中设置JAVA\_HOME：




JAVA_HOME=/usr/lib/jvm/jdk-11

保存文件并退出编辑器。
重启Tomcat以使更改生效。




$CATALINA_HOME/bin/shutdown.sh
$CATALINA_HOME/bin/startup.sh

验证Tomcat是否使用了新的JDK版本。




ps -ef | grep java

确保在ps的输出中看到的是新JDK路径。

注意：如果你的系统中有多个JDK版本，请确保指定的路径是你想要Tomcat使用的那个版本的路径。

- 阅读更多 -

Springboot集成websocket

System

2024-08-29

所有,java

在Spring Boot中集成WebSocket，你可以使用Spring的@EnableWebSocketMessageBroker注解来配置一个WebSocket消息代理。以下是一个简单的例子：

添加依赖到你的pom.xml：




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

配置WebSocketMessageBroker：




import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
 
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }
 
    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}

创建一个控制器来处理WebSocket消息：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
@Controller
public class WebSocketController {
 
    @MessageMapping("/hello")
    @SendTo("/topic/greetings")
    public String greeting(String message) {
        return "Hello, " + message + "!";
    }
}

前端使用SockJS和STOMP：




<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1.7.0/dist/sockjs.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/stompjs@2.3.3/stomp.min.js"></script>
<script>
    var socket = new WebSocket('ws://localhost:8080/ws');
    var stompClient = Stomp.over(socket);
    stompClient.connect({}, function(frame) {
        console.log('Connected: ' + frame);
        stompClient.subscribe('/topic/greetings', function(greeting){
            console.log(greeting.body);
        });
    });
    
    function sendName() {
        s

- 阅读更多 -

深入剖析Tomcat Session的实现原理

System

2024-08-29

所有,java

Tomcat中的Session实现主要在org.apache.catalina.session包中。以下是核心类的简化说明：

StandardSession：实现了javax.servlet.http.HttpSession接口，是Tomcat中Session的核心类。它维护Session的状态，包括属性、创建时间、最后访问时间等。
ManagerBase：实现了javax.servlet.http.HttpSessionManager接口，是所有Session管理器的基类。它定义了管理Session的通用方法，包括加载、保存、创建、删除Session等。
PersistentManagerBase：继承自ManagerBase，添加了持久化Session的能力，通过实现Lifecycle接口，可以在Tomcat启动和关闭时进行Session的加载和保存。
DeltaManager：实现了Session的增量保存机制，只保存自上次保存以来有变化的Session属性。

以下是StandardSession的关键方法的简化代码：




public class StandardSession implements HttpSession {
    private long creationTime = System.currentTimeMillis();
    private long lastAccessedTime;
    private boolean isValid = true;
    private Map<String, Object> attributes = new HashMap<>();
 
    public long getCreationTime() {
        return creationTime;
    }
 
    public void setLastAccessedTime(long time) {
        this.lastAccessedTime = time;
    }
 
    public long getLastAccessedTime() {
        return lastAccessedTime;
    }
 
    public boolean isValid() {
        return isValid;
    }
 
    public void invalidate() {
        isValid = false;
    }
 
    public void setAttribute(String name, Object value) {
        attributes.put(name, value);
    }
 
    public Object getAttribute(String name) {
        return attributes.get(name);
    }
 
    // 其他方法...
}

这个简化的例子展示了StandardSession类的基本结构和一些核心方法。实际的Tomcat实现还涉及到更多细节，例如Session的序列化、管理机制、分布式Session支持等。

- 阅读更多 -

SpringBoot的 8 个优点

System

2024-08-29

所有,java

Spring Boot 是由 Pivotal 团队提供的全新框架，设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。它主要是针对 Spring 应用的快速启动及运行提出的解决方案。

以下是 Spring Boot 的一些主要优点：

快速开发
Spring Boot 使用了特定的方式来进行配置，允许开发者使用少量的配置或者不使用配置就可以开启各种功能。
自动化配置
Spring Boot 的自动配置是一个非常重要的特性，它可以自动配置常用的库，比如 Eureka, Ribbon, Hystrix 等。
没有代码生成和XML配置
Spring Boot 不需要XML配置，它使用了条件注解来简化配置过程。
运行方便
可以打包为jar并使用java -jar运行，也可以打包为war包放入Tomcat服务器中运行。
与云计算集成
Spring Boot 提供了与云计算平台（如Cloud Foundry和Heroku）的集成。
与各种IDE兼容
包括 IntelliJ IDEA、Eclipse、NetBeans 等。
微服务支持
Spring Boot 提供了开箱即用的微服务支持，包括 Eureka、Hystrix、Zuul 等。
支持各种数据库
常见的数据库（如MySQL、PostgreSQL、H2等）无需额外配置即可使用。

以上是 Spring Boot 的一些主要优点，具体使用时需要根据实际需求来选择合适的特性。

- 阅读更多 -

springMVC处理请求全过程

System

2024-08-29

所有,java

Spring MVC处理请求的全过程大致如下：

用户发送请求到前端控制器(DispatcherServlet)。
DispatcherServlet接收请求并处理。
DispatcherServlet查询处理器映射器(HandlerMapping)找到处理请求的控制器(Controller)。
DispatcherServlet请求处理器适配器(HandlerAdapter)执行找到的控制器。
控制器(Controller)进行业务逻辑处理，返回ModelAndView对象。
HandlerAdapter将Controller执行结果的ModelAndView对象返回给DispatcherServlet。
DispatcherServlet将ModelAndView传给视图解析器(ViewResolver)进行解析。
ViewResolver解析后返回具体View。
DispatcherServlet对View进行渲染也就是将模型数据填充至视图中。
DispatcherServlet响应用户。

以下是一个简单的Spring MVC控制器示例：




@Controller
public class ExampleController {
 
    @RequestMapping(value = "/example", method = RequestMethod.GET)
    public ModelAndView handleRequest() {
        ModelAndView mav = new ModelAndView();
        mav.setViewName("exampleView");
        mav.addObject("message", "Hello, Spring MVC!");
        return mav;
    }
}

在这个例子中，当请求发送到/example时，Spring MVC的处理过程将会执行handleRequest方法，并最终返回名为exampleView的视图，同时在模型中添加一个名为message的属性，其值为Hello, Spring MVC!。

- 阅读更多 -