2024-09-04



import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
 
@Component
public class MyCustomBean implements InitializingBean, DisposableBean {
 
    private String message;
 
    public MyCustomBean() {
        System.out.println("构造器调用");
    }
 
    // 依赖注入
    public void setMessage(String message) {
        this.message = message;
    }
 
    // 初始化方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean 的 afterPropertiesSet 方法调用");
    }
 
    // 自定义初始化方法
    public void customInit() {
        System.out.println("customInit 方法调用");
    }
 
    // 自定义销毁方法
    public void customDestroy() {
        System.out.println("customDestroy 方法调用");
    }
 
    // 销毁方法
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean 的 destroy 方法调用");
    }
}

在Spring Boot应用中,这段代码定义了一个自定义的Bean,它实现了InitializingBeanDisposableBean接口,以便在Bean的初始化和销毁阶段执行自定义逻辑。在Bean的构造之后,所有必要的属性设置完成后,会调用afterPropertiesSet()方法。同样,在容器关闭时,会调用destroy()方法。这样,开发者可以在这些方法中插入自己的初始化和清理逻辑。

2024-09-04

为了将Tomcat集成到IntelliJ IDEA中,你需要按照以下步骤操作:

  1. 打开IntelliJ IDEA。
  2. 创建一个新的Web项目或打开现有的Web项目。
  3. 点击右侧的 "Run" 菜单,选择 "Edit Configurations"。
  4. 点击 "+" 按钮,选择 "Tomcat Server" 下的 "Local"。
  5. 在 "Server" 选项卡中,设置Tomcat服务器的路径。
  6. 在 "Deployment" 选项卡中,添加你的Web应用,并设置应用的上下文路径。
  7. 应用并关闭设置窗口。
  8. 点击运行按钮(绿色三角形)启动Tomcat服务器。

以下是一个简单的示例代码,演示如何在IDEA中配置Tomcat服务器:




import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
 
public class HelloWorldServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><body><h1>Hello World</h1></body></html>");
    }
}

在web.xml中注册Servlet:




<servlet>
    <servlet-name>HelloWorld</servlet-name>
    <servlet-class>HelloWorldServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>HelloWorld</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

确保Tomcat运行后,你可以通过浏览器访问 http://localhost:8080/你的应用路径/hello 来查看结果。

2024-09-04

要在Vite + Vue 3项目中实现Tomcat的本地部署,你需要执行以下步骤:

  1. 创建Vue 3项目(如果你还没有):



npm create vite@latest my-vue-app --template vue-ts
cd my-vue-app
npm install
  1. 配置Vite:

    vite.config.ts文件中,你可以配置服务器设置,例如端口号和基本URL。

  2. 构建项目:



npm run build
  1. 将构建的文件复制到Tomcat的webapps目录下的一个新文件夹中。
  2. 启动Tomcat服务器。
  3. 在浏览器中访问Tomcat服务器的地址加上你的应用文件夹名称。

例如,如果Tomcat运行在本地的8080端口,并且你的应用文件夹名为myapp,你可以访问:




http://localhost:8080/myapp

以下是一个简单的Vite配置示例:




// vite.config.ts
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';
 
// https://vitejs.dev/config/
export default defineConfig({
  plugins: [vue()],
  server: {
    port: 3000, // 设置Vite开发服务器的端口号
    open: true, // 是否在启动服务器时自动打开浏览器
  },
});

确保你的Tomcat服务器已经安装并正确配置在你的本地环境中。然后按照上述步骤操作,将Vue 3应用部署到Tomcat。

2024-09-04



# 安装Docker
sudo apt-get update
sudo apt-get install docker.io
 
# 启动Docker服务
sudo systemctl start docker
 
# 确认Docker已经安装成功
docker --version
 
# 拉取Tomcat镜像
docker pull tomcat:9.0
 
# 运行Tomcat容器
docker run --name my-tomcat -p 8080:8080 -d tomcat:9.0
 
# 检查容器状态
docker ps
 
# 访问Tomcat
curl http://localhost:8080

这段代码展示了如何在Ubuntu系统上安装Docker,并使用Docker来运行一个Tomcat 9容器。代码简洁,注重实用性,可以作为Linux运维开发的一个实战示例。

2024-09-04

在VSCode中搭建Spring Boot项目的基本步骤如下:

  1. 确保你的计算机上安装了Java Development Kit (JDK)。
  2. 安装Spring Boot CLI,可以通过以下命令:

    
    
    
    curl -s https://start.spring.io/starter.tgz -d dependencies=web | tar -xzvf -
  3. 安装VSCode和必要的插件:

    • Language Support for Java(TM) by Red Hat
    • Debugger for Java
    • Spring Boot Dashboard
    • Maven for Java
  4. 在VSCode中打开或者导入Spring Boot项目。
  5. 使用Maven或Gradle构建和运行项目。

以下是一个简单的Spring Boot项目的pom.xml文件示例:




<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
 
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
 
    <properties>
        <java.version>1.8</java.version>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
 
</project>

确保你的VSCode设置中配置了正确的JDK路径,并且你的项目可以通过Maven或Gradle构建。如果你使用的是Maven,可以在项目根目录下运行mvn spring-boot:run来启动Spring Boot应用。如果使用Gradle,则可以运行./gradlew bootRun

2024-09-04

以下是一个简化的Shell脚本示例,用于对Tomcat和Nginx日志进行切割:




#!/bin/bash
 
# 定义日志文件所在的目录
LOG_DIR="/var/log/tomcat"
 
# 对Tomcat的catalina.out日志进行切割
cd $LOG_DIR
TOMCAT_LOG="catalina.out"
SIZE_LIMIT="100M"
 
# 如果日志文件大于100M,则进行切割
if [ -f "$TOMCAT_LOG" -a -s "$TOMCAT_LOG" ]; then
  SIZE=$(du -b "$TOMCAT_LOG" | cut -f 1)
  if [ "$SIZE" -gt "$SIZE_LIMIT" ]; then
    mv "$TOMCAT_LOG" "${TOMCAT_LOG}.$(date +%Y%m%d%H%M%S)"
    touch "$TOMCAT_LOG"
    chown tomcat:tomcat "$TOMCAT_LOG"
  fi
fi
 
# 对Nginx的access.log和error.log进行切割
NGINX_LOG="/var/log/nginx"
for LOG in "access.log" "error.log"; do
  if [ -f "${NGINX_LOG}/${LOG}" -a -s "${NGINX_LOG}/${LOG}" ]; then
    mv "${NGINX_LOG}/${LOG}" "${NGINX_LOG}/${LOG}.$(date +%Y%m%d%H%M%S)"
    touch "${NGINX_LOG}/${LOG}"
    chown nginx:nginx "${NGINX_LOG}/${LOG}"
  fi
done
 
# 使用logrotate进行系统自带的日志轮转
logrotate /etc/logrotate.conf

这个脚本首先定义了日志文件所在的目录,然后对Tomcat的catalina.out日志和Nginx的access.log和error.log进行切割。切割后,使用logrotate命令应用系统的日志轮转配置,以自动处理其他系统日志文件的切割和压缩。

2024-09-04

在 IntelliJ IDEA 中配置 Tomcat 服务器用于部署 Java Web 应用程序的步骤如下:

  1. 打开 IntelliJ IDEA,选择 "File" -> "Project Structure" 或者直接点击工具栏上的 "Project Structure" 图标。
  2. 在左侧菜单中选择 "Project Settings" -> "Modules"。
  3. 选择你的 Web 应用模块,点击 "Facets" 标签页,然后点击 "+" -> "Web" -> "Web"。
  4. 在 "Web Resource Directory" 字段中,指定你的 Web 资源目录(通常是 webWebContent)。
  5. 在 "Web Inf Directory" 字段中,指定你的 WEB-INF 目录路径。
  6. 点击 "Apply" 和 "OK" 保存设置。
  7. 返回 "Project Structure" 界面,选择 "Frameworks" 下的 "+" -> "Web Application"。
  8. 在弹出的对话框中,选择你的模块。
  9. 点击 "Apply" 和 "OK" 保存设置。

配置好之后,你可以进行如下操作来配置 Tomcat 服务器:

  1. 打开 "Run" 菜单,选择 "Edit Configurations"。
  2. 点击 "+" -> "Tomcat Server" -> "Local"。
  3. 在 "Server" 选项卡中,点击 "Configure",选择你的 Tomcat 安装目录。
  4. 在 "Deployment" 选项卡中,点击 "+" -> "Artifact",选择你的 Web 应用构建产物。
  5. 设置 "Application server" 为你刚才配置的 Tomcat 服务器。
  6. 为你的应用设置 "Application context"。
  7. 点击 "Apply" 和 "OK" 保存设置。

现在你可以点击 IntelliJ IDEA 工具栏上的 "Run" 按钮来启动 Tomcat 服务器,并且部署你的 Web 应用程序。

2024-09-04

OpenFeign是一个声明式的Web服务客户端,它的目的是让微服务之间的调用变得更简单。在Spring Cloud中,它使用了Feign客户端的声明式注解来调用服务。

以下是一个使用Spring Cloud OpenFeign的示例:

  1. 首先,你需要在你的Spring Cloud应用的pom.xml中添加Spring Cloud OpenFeign的依赖:



<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
  1. 在你的Spring Boot应用的主类或者配置类上添加@EnableFeignClients注解来启用Feign客户端:



@EnableFeignClients
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
  1. 创建一个Feign客户端接口,使用@FeignClient注解来指定服务名称,然后使用@GetMapping@PostMapping等注解来声明具体的远程调用:



@FeignClient(name = "service-provider")
public interface ServiceProviderClient {
    @GetMapping("/data")
    String getData();
 
    @PostMapping("/submit")
    void submitData(@RequestBody MyData data);
}

在上面的代码中,service-provider是你要调用的服务的名称。@GetMapping("/data")@PostMapping("/submit")分别声明了对服务中/data/submit端点的GET和POST请求。

  1. 在你的服务中,你可以注入这个Feign客户端,并像使用本地方法一样调用远程服务:



@RestController
public class MyController {
    @Autowired
    private ServiceProviderClient serviceProviderClient;
 
    @GetMapping("/localData")
    public String getLocalData() {
        String data = serviceProviderClient.getData();
        // 处理获取的数据
        return data;
    }
 
    @PostMapping("/submitLocalData")
    public void submitLocalData(@RequestBody MyData myData) {
        serviceProviderClient.submitData(myData);
        // 处理提交的数据
    }
}

在上面的代码中,ServiceProviderClient是一个Feign客户端,用于调用远程服务。

这就是Spring Cloud OpenFeign的基本使用方法。通过这种方式,你可以在Spring Cloud应用中轻松地调用其他服务的REST接口。

2024-09-04



@Configuration
public class MyBatisConfig {
 
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        // 可以设置更多的MyBatis全局配置 like 'mapperLocations' and 'configLocation'
        return sqlSessionFactoryBean.getObject();
    }
 
    @Bean
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/myapp");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }
 
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        mapperScannerConfigurer.setBasePackage("com.myapp.mapper");
        return mapperScannerConfigurer;
    }
}

这个配置类展示了如何在Spring中配置MyBatis的SqlSessionFactory、DataSource以及自动扫描Mapper接口。这是一个基本的配置模板,可以根据实际情况进行调整和扩展。

2024-09-04

Spring Cloud Alibaba 提供了配置中心的组件,可以帮助我们更好地管理应用的配置信息。以下是如何使用 Spring Cloud Alibaba 配置中心的简单示例。

  1. 首先,在 pom.xml 中添加 Spring Cloud Alibaba 配置中心的依赖:



<dependencies>
    <!-- Spring Cloud Alibaba Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
</dependencies>
  1. 在 application.properties 或 application.yml 文件中配置 Nacos 服务器的地址和应用名:



spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.application.name=my-application
  1. 启动类上添加 @EnableDiscoveryClient 注解:



import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@SpringBootApplication
@EnableDiscoveryClient
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
  1. 创建一个配置管理的 Controller 来获取配置信息:



import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@RefreshScope
public class ConfigController {
 
    @Value("${my.config}")
    private String myConfig;
 
    @GetMapping("/config")
    public String getConfig() {
        return myConfig;
    }
}
  1. 在 Nacos 控制台配置对应的配置信息,并设置相应的 Data ID 和 Group。

当需要更新配置时,可以通过 Nacos 控制台发布新的配置,或者使用 Nacos 的 Open API 发布配置。应用会自动检测到配置的变化,并更新配置信息。

以上是使用 Spring Cloud Alibaba 配置中心的基本步骤和示例代码。在实际应用中,还需要考虑安全性,权限控制,配置的版本管理等问题。