分类后端技术下的文章

2024-09-04

Tomcat的组件架构主要包括连接器（Connectors），容器（Containers）和服务（Services）。连接器负责处理网络连接，容器负责管理Servlet的执行环境，服务则将它们组合在一起提供Web服务。

以下是Tomcat的简化组件示意图：




          __________
         |         |
         | Connectors|
         |         |
         |_________|
            /     \
           /       \
      ______      ______
     |      |    |      |
     |      |    |      |
     | Container | Container | ...
     |      |    |      |
     |______|    |______|
            \     /
             \   /
              ______
             |      |
             |      |
             | Service |
             |      |
             |______|

数据流示意图：




Client <-> Connector <-> Container <-> Servlet <-> DB

Client：客户端发送请求到Tomcat服务器。

Connector：负责接收客户端请求，并将请求封装成Request和Response对象。

Container：负责管理和执行Servlet，处理请求和生成响应。

Servlet：实际处理业务逻辑的组件。

DB：数据库，如果需要的话，Servlet处理完业务逻辑后与数据库交互。

代码实例不适合在这里给出，因为这涉及到具体的业务逻辑实现。但是，可以提供一个简单的Servlet示例来说明数据是如何在Tomcat中流动的：




import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
 
public class SimpleServlet extends HttpServlet {
    public 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>");
    }
}

这个简单的Servlet处理GET请求，并响应一个包含“Hello World”的HTML页面。在实际部署到Tomcat后，客户端的请求会通过Connector，被传递给Servlet容器，然后Servlet容器会调用这个Servlet的doGet方法来处理请求，并生成响应返回给客户端。

System

2024-09-04

所有,java




import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
 
// 自定义事件
public class MyCustomEvent extends ApplicationEvent {
    public MyCustomEvent(Object source) {
        super(source);
    }
}
 
// 自定义监听器
@Configuration
public class MyCustomListener implements ApplicationListener<MyCustomEvent> {
    @Override
    public void onApplicationEvent(MyCustomEvent event) {
        // 处理事件逻辑
        System.out.println("MyCustomListener received MyCustomEvent: " + event);
    }
}
 
// 触发事件的地方
@Configuration
public class EventPublisher {
    
    private final ApplicationEventPublisher publisher;
 
    public EventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }
 
    public void publish() {
        MyCustomEvent event = new MyCustomEvent(this);
        publisher.publishEvent(event);
    }
}
 
// 在SpringBoot启动完成后发布事件
@Configuration
public class StartupListener implements ApplicationListener<ContextRefreshedEvent> {
    private final EventPublisher eventPublisher;
 
    public StartupListener(EventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
 
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (event.getApplicationContext().getParent() == null) {
            // 发布事件
            eventPublisher.publish();
        }
    }
}

这个代码示例展示了如何在SpringBoot应用中定义、监听和发布自定义事件。MyCustomEvent是一个自定义事件类，MyCustomListener是监听该事件的监听器。EventPublisher类中的publish方法用于发布事件，而StartupListener则在SpringBoot启动完成后发布事件。这个例子有助于理解Spring的事件机制，并在实际应用中进行事件驱动的开发。

- 阅读更多 -

CentOS7 安装Oracle11g（备忘）

System

2024-09-04

所有,数据库

由于Oracle 11g不再支持CentOS 7，安装过程可能会遇到许多问题。以下是安装Oracle 11g的基本步骤，但是不保证每个步骤都能成功执行，因为官方不再提供支持：

系统要求：
- 至少2GB物理内存
- 至少400MB的交换空间
- 至少3GB可用磁盘空间

安装必要的依赖包：




sudo yum install -y binutils compat-libstdc++-33 elfutils-libelf elfutils-libelf-devel gcc gcc-c++ glibc glibc-common glibc-devel glibc-headers ksh libaio libaio-devel libgcc libstdc++ libstdc++-devel libXi libXtst make sysstat

创建Oracle用户和组：




sudo groupadd oinstall
sudo groupadd dba
sudo useradd -g oinstall -G dba oracle
sudo passwd oracle

配置内核参数和用户限制，编辑或添加以下行到 /etc/sysctl.conf 和 /etc/security/limits.conf：




# /etc/sysctl.conf
fs.file-max = 6815744
kernel.sem = 250 32000 100 128
kernel.shmmax = 536870912
net.ipv4.ip_local_port_range = 1024 65000
net.core.rmem_default = 262144
net.core.rmem_max = 4194304
net.core.wmem_default = 262144
net.core.wmem_max = 1048576
 
# /etc/security/limits.conf
oracle soft nproc 2047
oracle hard nproc 16384
oracle soft nofile 1024
oracle hard nofile 65536

应用内核参数更改：
```
sudo sysctl -p
```

创建Oracle安装目录并设置权限：




sudo mkdir -p /u01/app/oracle
sudo chown -R oracle:oinstall /u01
sudo chmod -R 775 /u01

设置Oracle用户的环境变量，编辑~oracle/.bash_profile：




export ORACLE_BASE=/u01/app/oracle
export ORACLE_HOME=$ORACLE_BASE/product/11.2.0/db_1
export ORACLE_SID=ORCL
export PATH=$PATH:$ORACLE_HOME/bin

登录到Oracle用户并下载Oracle 11g安装文件。

解压安装文件并运行安装程序：




unzip oracle_database_linux32.zip
cd database/
./runInstaller

安装完成后，运行Oracle的配置助手(CA)：
```
$ORACLE_HOME/bin/dbca
```

最后，配置Oracle的监听器和网络设置：




$ORACLE_HOME/bin/netca
$ORACLE_HOME/bin/lsnrctl start

注意：这只是一个基本的安装指南，实际安装可能需要根据系统环境和具体需求做出调整。由于CentOS 7不再支持，Oracle官方没有提供对11g的支持

- 阅读更多 -

oracle 补齐两位小数（不足补0）以及前面补0（不到1的小数）

System

2024-09-04

所有,数据库

在Oracle中，补齐两位小数可以使用TO_CHAR函数结合FM999999990.00格式模型，而要在不足两位小数时前面补零，可以使用LPAD函数。

以下是一个示例，演示如何对数字进行两位小数的补齐，以及在小数点前补零：




SELECT TO_CHAR(your_column, 'FM999999990.00') AS padded_number
FROM your_table;

如果你想要在小于1的数字前面补0，可以使用LPAD函数结合TO_CHAR函数：




SELECT LPAD(TO_CHAR(your_column, 'FM99999990.00'), 12, '0') AS padded_number
FROM your_table;

这里，LPAD函数将TO_CHAR格式化后的结果补到12位长度，不足的部分通过第三个参数'0'进行了前补零。

System

2024-09-04

所有,redis

这里提供一个简化版本的分布式锁实现，使用Redis和ZooKeeper的简单示例。

Redis分布式锁实现：




import redis.clients.jedis.Jedis;
 
public class RedisDistributedLock {
    private Jedis jedis;
    private String lockKey;
    private int expireTime; // 锁的超时时间
 
    public RedisDistributedLock(Jedis jedis, String lockKey, int expireTime) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.expireTime = expireTime;
    }
 
    public boolean lock() {
        String result = jedis.set(lockKey, "locked", "NX", "PX", expireTime);
        return "OK".equals(result);
    }
 
    public boolean unlock() {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList("locked"));
        return result.equals(1L);
    }
}

Zookeeper分布式锁实现：




import org.apache.zookeeper.*;
 
public class ZkDistributedLock implements Watcher {
    private ZooKeeper zk;
    private String lockName;
    private String waitNode;
 
    public ZkDistributedLock(String hostPort, String lockName) throws Exception {
        this.lockName = lockName;
        zk = new ZooKeeper(hostPort, 3000, this);
        waitNode = zk.create("/locks/" + lockName, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
    }
 
    public void lock() throws KeeperException, InterruptedException {
        while (true) {
            try {
                zk.exists("/locks/" + lockName, true);
                System.out.println("Waiting for lock...");
                synchronized (this) {
                    wait();
                }
                System.out.println("Lock acquired");
                break;
            } catch (KeeperException.NoNodeException e) {
                // Lock acquired
                break;
            }
        }
    }
 
    public void unlock() throws KeeperException, InterruptedException {
        zk.delete(waitNode, -1);
        zk.close();
    }
 
    @Override
    public void process(WatchedEvent event) {
        if (event.getType() == Event.EventType.NodeDeleted) {
            synchronized (this) {
                notifyAll();
            }
        }
    }
}

以上代码提供了使用Redis和Zookeeper实现分布式锁的简单示例。在实际应用中，你需要根据具体需求进行安全性和性能的优化，例如使用参数化的Redis命令防止死锁，或者使用Zookeeper的有序节点来实现锁。

- 阅读更多 -

Django Memcached 状态监控指南

System

2024-09-04

所有,数据库




from django.core.cache import caches
from django.http import JsonResponse
 
# 假设已经在Django设置中配置了memcached缓存
caches['default'].set('key', 'value', timeout=3600)
 
def memcached_stats():
    cache = caches['default']
    stats = cache.get_backend_class().stats()
    if stats:
        return JsonResponse({'status': 'OK', 'stats': stats})
    else:
        return JsonResponse({'status': 'ERROR', 'message': 'No stats available'}, status=500)
 
# 使用上述函数可以获取当前memcached实例的状态信息

这个简单的示例展示了如何在Django中获取和返回memcached的状态信息。这个函数尝试获取memcached的状态数据，如果成功，它将返回一个包含状态为'OK'和状态数据的JSON响应；如果失败，它将返回一个状态为'ERROR'的JSON响应，并带有错误信息，同时设置HTTP状态码为500。这个简单的函数可以作为监控memcached健康状况的基础。

- 阅读更多 -

SpringBoot——国际化

System

2024-09-04

所有,java

Spring Boot 提供了一个强大的机制来实现应用程序的国际化，即通过消息资源（Message Source）。

以下是一个简单的例子，展示如何在Spring Boot中实现国际化：

在 src/main/resources 目录下创建消息资源文件：




messages_en.properties
messages_es.properties
messages_fr.properties

对于每个语言的文件，你可以定义相应的键值对，例如：

messages_en.properties




greeting=Hello

messages_es.properties




greeting=Hola

messages_fr.properties




greeting=Bonjour

在Spring Boot应用程序中，注入 MessageSource 并使用它来获取本地化消息：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;
import org.springframework.stereotype.Service;
 
import java.util.Locale;
 
@Service
public class MessageService {
 
    @Autowired
    private MessageSource messageSource;
 
    public String getMessage(String key, Locale locale) {
        return messageSource.getMessage(key, null, locale);
    }
}

在控制器中使用 MessageService 来获取本地化的消息：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.Locale;
 
@RestController
public class GreetingController {
 
    @Autowired
    private MessageService messageService;
 
    @GetMapping("/greeting")
    public String greeting(@RequestParam(value = "lang", defaultValue = "en") String language) {
        Locale locale = new Locale(language);
        return messageService.getMessage("greeting", locale);
    }
}

当你访问 /greeting?lang=en，你会得到 "Hello"，访问 /greeting?lang=es，你会得到 "Hola"，以此类推。

这个例子演示了如何在Spring Boot应用程序中设置和使用国际化。通过这种方式，你可以很容易地为你的应用程序提供多语言支持。

- 阅读更多 -

【Spring Cloud Alibaba】1.Nacos安装和介绍

System

2024-09-04

所有,java

Nacos 是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

安装 Nacos 需要以下步骤：

下载 Nacos: 访问 Nacos 官方 GitHub 仓库下载最新的 Nacos 二进制包。
解压 Nacos: 将下载的 Nacos 包解压到指定目录。
启动 Nacos: 进入 Nacos 的 bin 目录，执行启动脚本。

以下是在 Linux 环境下的简要步骤：




# 下载 Nacos
wget https://github.com/alibaba/nacos/releases/download/[版本号]/nacos-server-[版本号].tar.gz
 
# 解压 Nacos
tar -zxvf nacos-server-[版本号].tar.gz
 
# 进入 Nacos 目录
cd nacos/bin
 
# 启动 Nacos，Standalone 代表 Nacos 以单机模式运行
./startup.sh -m standalone

启动后，可以访问 Nacos 的控制台，默认地址是 http://127.0.0.1:8848/nacos，用户名和密码都是 nacos。

Nacos 的介绍和使用场景非常广泛，主要用于服务注册与发现，配置管理等。在 Spring Cloud Alibaba 中，可以很容易地集成 Nacos 作为服务注册中心和配置中心。

System

2024-09-04

所有,java




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.reactive.TransactionalOperator;
import reactor.core.publisher.Mono;
 
@Service
public class TransactionalService {
 
    @Autowired
    private TransactionalOperator transactionalOperator;
 
    @Autowired
    private YourRepository yourRepository;
 
    public Mono<YourEntity> updateEntity(YourEntity entity) {
        return transactionalOperator.executeAndAsk(
            // 这里使用 yourRepository 来执行数据库操作，它们将在同一事务中执行
            transactionalOperator.transactional(yourRepository.update(entity))
        );
    }
}

在这个例子中，我们定义了一个服务类TransactionalService，它使用TransactionalOperator来管理WebFlux项目中的事务。在updateEntity方法中，我们使用了transactionalOperator.executeAndAsk来确保在同一个事务中执行数据库的更新操作。这里的YourRepository是一个假设的接口，你需要根据你的实际数据库操作接口来替换。

System

2024-09-04

所有,java

在Spring Boot 2.2.5中，你可以通过以下步骤使用Undertow替换默认的Tomcat服务器，并同时支持HTTP/2和HTTP/1.1：

在pom.xml中添加依赖：




<!-- 引入Spring Boot的Undertow依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>
 
<!-- 排除Tomcat依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

在application.properties或application.yml中配置Undertow服务器：




# application.properties
 
# 设置Undertow服务器的内嵌Servlet容器
server.undertow.enabled=true
 
# 是否启用HTTP/2，需要配合服务器的HTTP/2支持和TLS
server.undertow.http2-enabled=true

配置HTTP/2的前提是你的服务器支持HTTP/2，并且你需要通过配置SSL/TLS来启用HTTP/2。确保你的服务器证书支持ALPN（应用层协议协商），因为这是HTTP/2的必要条件。




# 设置SSL
server.ssl.key-store=classpath:keystore.jks
server.ssl.key-store-password=yourpassword
server.ssl.key-password=yourkeypassword

确保你的应用程序中没有任何显式配置来启用Tomcat。

以上步骤可以帮助你在Spring Boot 2.2.5中使用Undertow服务器，并启用HTTP/2支持。这可以显著提高性能，尤其是在处理高并发的REST API时。

- 阅读更多 -