分类后端技术下的文章

2024-09-02

所有,java

Zookeeper是一个开源的分布式协调服务，用于解决分布式系统中的一致性问题、配置管理、分组和命名服务等问题。Spring Cloud提供了对Zookeeper的支持，可以用来实现服务注册与发现、分布式锁、分布式队列等功能。

以下是Spring Cloud中使用Zookeeper的一些常见场景：

服务注册与发现：Zookeeper可以作为Spring Cloud的服务注册中心，例如Eureka。服务提供者将自己的服务信息注册到Zookeeper中，服务消费者可以从Zookeeper获取服务列表信息。
配置管理：Spring Cloud Config可以使用Zookeeper作为配置存储，实现配置信息的集中管理。
分布式锁：Zookeeper可以被用来实现分布式锁，确保同一时刻只有一个实例来执行某项任务。
分布式队列：Zookeeper可以被用来实现分布式队列，例如Kafka。

使用Spring Cloud Zookeeper的基本步骤：

在pom.xml中添加Spring Cloud Zookeeper的依赖。




<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
    </dependency>
</dependencies>

在application.properties或application.yml中配置Zookeeper服务器信息。




spring.cloud.zookeeper.connect-string=localhost:2181

将@EnableDiscoveryClient注解添加到应用的主类上。




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@EnableDiscoveryClient
@SpringBootApplication
public class ZookeeperApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZookeeperApplication.class, args);
    }
}

创建服务提供者和服务消费者，并使用@Value注解或者DiscoveryClient来获取服务信息。

以上是使用Spring Cloud Zookeeper的基本框架，具体使用时还需要根据实际需求进行配置调整和功能扩展。

【AIGC】mac本地采用GPU启动keras运算

2024-09-02

所有,AIGC

在Mac本上使用GPU加速Keras计算，通常需要CUDA兼容的GPU和相应的深度学习框架，如TensorFlow与Keras的结合。以下是一个简单的例子，展示如何配置并使用GPU来加速Keras训练。

安装TensorFlow和Keras：




pip install tensorflow
pip install keras

确保已经安装了CUDA Toolkit和cuDNN，并且它们与TensorFlow版本兼容。
在代码中，确保配置TensorFlow使用GPU：




import tensorflow as tf
from tensorflow.keras import models, layers, optimizers
 
# 确保TensorFlow使用GPU
gpus = tf.config.list_physical_devices('GPU')
if gpus:
    tf.config.experimental.set_memory_growth(gpus[0], True)
    tf.config.set_visible_devices(gpus[0], 'GPU')
 
# 构建模型
model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(100,)))
model.add(layers.Dense(10, activation='softmax'))
 
model.compile(optimizer=optimizers.RMSprop(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])
 
# 模型训练数据准备...
 
# 开始训练
model.fit(x_train, y_train, epochs=10)

确保在运行代码前已经安装了CUDA Toolkit和cuDNN，并且它们与TensorFlow版本相兼容。如果GPU不可见或者不能被TensorFlow使用，请检查CUDA和cuDNN的安装路径和版本兼容性。

Web 开发 9：Django 框架基础

2024-09-02




# 导入Django模块
import django
from django.http import HttpResponse
 
# 定义一个简单的视图函数
def index(request):
    return HttpResponse("Hello, Django!")
 
# 定义一个返回项目版本的视图函数
def version(request):
    return HttpResponse(django.get_version())
 
# 定义一个返回项目模板的视图函数
from django.template import Context, Template
def template(request):
    t = Template("<html><head><title>Django</title></head><body>Hello, {{ name }}</body></html>")
    c = Context({"name": "Django"})
    return HttpResponse(t.render(c))

这段代码演示了如何在Django中创建简单的视图函数，以及如何使用Django模板系统来渲染动态内容。这些函数可以作为Django视图的一部分，在URL配置中被调用，以响应用户的请求。

Redis之golang编程实战

2024-09-02

所有,redis




package main
 
import (
    "fmt"
    "github.com/go-redis/redis/v8"
    "context"
)
 
var ctx = context.Background()
 
func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // 默认没有密码，如果设置了需要填写
        DB:       0,  // 默认数据库为0
    })
 
    // 设置键值
    err := rdb.Set(ctx, "key", "value", 0).Err()
    if err != nil {
        panic(err)
    }
 
    // 获取键的值
    val, err := rdb.Get(ctx, "key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("key", val) // 输出: key value
 
    // 删除键
    err = rdb.Del(ctx, "key").Err()
    if err != nil {
        panic(err)
    }
 
    // 再次获取键的值，应该返回nil
    val, err = rdb.Get(ctx, "key").Result()
    if err == redis.Nil {
        fmt.Println("key does not exist") // 输出: key does not exist
    } else if err != nil {
        panic(err)
    } else {
        fmt.Println("key", val)
    }
}

这段代码展示了如何在Go语言中使用go-redis库来连接Redis服务器，并执行基本的SET、GET和DEL操作。同时，它还处理了可能出现的错误，并在最后进行了删除操作。这是学习Redis和Go语言编程的一个很好的起点。

oracle存储结构-----逻辑存储结构（表空间、段、区、块）

2024-09-02

Oracle数据库的逻辑存储结构主要包括以下几个部分：表空间、段、区和块。

表空间（Tablespace）：表空间是Oracle数据库中一个逻辑上的概念，它是由一个或多个数据文件组成。表空间用于存放数据库中的数据和元数据。
段（Segment）：段是Oracle中一个组织数据的逻辑存储结构，主要有数据段、索引段、回滚段等。
区（Extent）：当一个段需要更多的空间时，Oracle会为这个段分配一个或多个区。区是Oracle分配空间的基本单位，它是由连续的数据块组成的。
块（Block）：Oracle管理数据文件的基本单位，是数据库I/O的最小单位。一个块由一个或多个Oracle数据块（Oracle Data Blocks）组成。

以下是创建表空间、段、区的示例代码：




-- 创建表空间
CREATE TABLESPACE my_tablespace
  DATAFILE 'path_to_datafile.dbf' SIZE 100M
  AUTOEXTEND ON NEXT 10M MAXSIZE 500M;
 
-- 创建段（数据段）
CREATE TABLE my_table (
  id NUMBER,
  data VARCHAR2(100)
)
TABLESPACE my_tablespace;
 
-- 为段添加区
ALTER TABLE my_table
  ADD CONSTRAINT my_table_pk PRIMARY KEY (id)
  USING INDEX
  TABLESPACE my_tablespace;

在这个例子中，我们首先创建了一个名为my_tablespace的表空间，指定了数据文件的路径和大小，并设置了自动扩展的规则。然后我们创建了一个my_table表，并指定它使用my_tablespace表空间。最后，我们为my_table表的主键字段添加了一个索引，并指定了使用my_tablespace表空间来存储索引。这样，我们就创建了段、区，并且为这些区指定了表空间。

【ThinkPHP6 - 连接 SQLite 及遇到的一些问题】

2024-09-02




<?php
namespace app\model;
 
use think\Model;
use think\facade\Db;
 
class User extends Model
{
    // 设置完整数据表名（包含表前缀）
    protected $table = 'user';
 
    // 设置连接数据库的配置名称
    protected $connection = 'sqlite_connection';
 
    // 获取所有用户数据
    public function getAllUsers()
    {
        try {
            // 使用查询构造器查询数据
            $result = Db::table($this->table)->select();
            return $result;
        } catch (\Exception $e) {
            // 捕获异常并处理
            return false;
        }
    }
}

在这个示例中，我们定义了一个名为User的模型，它继承自think\Model。我们设置了模型对应的数据表名和连接名。在getAllUsers方法中，我们使用Db::table来执行查询并返回结果。如果在查询过程中发生异常，我们捕获异常并返回false。这个模式展示了如何在ThinkPHP6框架中使用连接SQLite数据库的基本方法。

2024-09-02

所有,java

WebMvcConfigurationSupport是Spring MVC框架中提供的一个用于定制Spring MVC配置的类。如果你想要添加自定义拦截器，你可以通过继承WebMvcConfigurationSupport并覆盖其addInterceptors方法来实现。

以下是一个如何使用addInterceptor方法添加自定义拦截器的例子：




import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import org.springframework.web.servlet.HandlerInterceptor;
 
@Configuration
public class WebConfig extends WebMvcConfigurationSupport {
 
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        HandlerInterceptor customInterceptor = new HandlerInterceptor() {
            @Override
            public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
                // 在请求处理之前进行调用（Controller方法调用之前）
                return true; // 如果返回false，则停止流程，api不会被调用
            }
 
            @Override
            public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
                // 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
            }
 
            @Override
            public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
                // 在整个请求结束之后调用，也就是在DispatcherServlet渲染了视图执行
            }
        };
 
        registry.addInterceptor(customInterceptor)
                .addPathPatterns("/**"); // 添加拦截路径
                //.excludePathPatterns("/login", "/error"); // 添加排除路径
    }
}

在这个例子中，我们定义了一个customInterceptor，它实现了HandlerInterceptor接口。然后我们将其注册到Spring MVC配置中，并指定所有路径/**都将被这个拦截器拦截。你也可以通过excludePathPatterns方法排除特定的路径。这样，每次请求/**路径时，都会先执行customInterceptor中的方法。

Spring Boot & Java：微服务世界的奇幻之旅

2024-09-02

所有,java

在Spring Boot中创建一个简单的微服务项目，你需要做以下几步：

创建一个Spring Boot项目。
添加必要的依赖，比如Spring Web和Spring Cloud。
配置微服务，比如服务发现和配置管理。
创建一个REST控制器来处理HTTP请求。

以下是一个简单的Spring Boot微服务示例代码：




// 导入必要的依赖
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@SpringBootApplication // 标记为Spring Boot应用
public class MicroserviceApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(MicroserviceApplication.class, args); // 启动应用
    }
}
 
@RestController // 表明这是一个REST控制器
class HelloWorldController {
 
    // 映射一个GET请求到根路径("/")
    @GetMapping("/")
    public String hello() {
        return "Hello, World!"; // 返回简单的问候
    }
}

这个微服务应用程序启动后，访问根路径（/）将返回“Hello, World!”。这是微服务开发的一个基本示例，实际微服务开发可能会涉及更复杂的逻辑和服务治理机制。

oracle怎样快速定位资源持有者

2024-09-02

在Oracle数据库中，要快速定位资源持有者，可以使用以下方法：

使用V$LOCK视图查看锁信息。
使用V$SESSION和V$PROCESS视图结合DBA_OBJECTS或ALL_OBJECTS视图查看持有锁的对象。

以下是一个示例SQL查询，用于定位资源持有者：




SELECT s.sid,
       s.serial#,
       p.spid AS OS_Process_ID,
       s.username,
       s.program
FROM v$session s,
     v$process p
WHERE p.addr = s.paddr
AND s.sid IN (SELECT DISTINCT session_id FROM v$locked_object);

这个查询会返回当前所有锁定对象的会话信息，包括会话ID、序列号、操作系统进程ID、用户名以及会话执行的程序。

如果你想要查看锁定的具体对象，可以使用以下查询：




SELECT lo.object_id,
       ao.object_name,
       ao.object_type,
       lo.session_id,
       s.serial#,
       p.spid AS OS_Process_ID,
       s.username,
       s.program
FROM v$locked_object lo
JOIN all_objects ao ON lo.object_id = ao.object_id
JOIN v$session s ON lo.session_id = s.sid
JOIN v$process p ON s.paddr = p.addr;

这个查询将显示所有锁定对象的信息，包括对象ID、对象名、对象类型、会话ID、会话序列号、操作系统进程ID、用户名以及会话执行的程序。

centos7部署redis和哨兵模式

2024-09-02

所有,redis

在CentOS 7上部署Redis和哨兵模式，你需要按照以下步骤操作：

安装Redis




sudo yum install epel-release -y
sudo yum update -y
sudo yum install redis -y

启动Redis服务




sudo systemctl start redis
sudo systemctl enable redis

配置Redis密码（可选）
编辑Redis配置文件 /etc/redis.conf，找到 requirepass 配置项，并设置你的密码：




requirepass your_password

配置哨兵模式
创建哨兵配置文件 /etc/redis-sentinel.conf，并添加以下内容：




sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000
 
# 如果你设置了Redis密码，还需要添加以下行
sentinel auth-pass mymaster your_password

启动哨兵




redis-sentinel /etc/redis-sentinel.conf

确保你已经根据实际情况修改了上述配置中的 your_password、127.0.0.1 和 6379。mymaster 是主节点的名字，可以根据实际情况自定义。2 表示至少需要2个哨兵同意主节点已经失效才会进行故障转移。

以上步骤可能需要根据你的实际需求进行调整，比如配置文件的位置、端口号、日志文件位置等。在实际部署时，你可能需要根据你的网络环境和安全策略来配置Redis和哨兵。