System 发布的文章

2024-09-04

在Spring Boot中调用第三方WebService接口，可以使用以下两种常见的方式：

使用Spring WS的WebServiceTemplate类。
使用JAX-WS。

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

方式一：使用`WebServiceTemplate`

import org.springframework.ws.client.core.WebServiceTemplate;

@Service
public class WebServiceClient {

    private final WebServiceTemplate webServiceTemplate;

    @Autowired
    public WebServiceClient(WebServiceTemplate webServiceTemplate) {
        this.webServiceTemplate = webServiceTemplate;
    }

    public Object callWebService(Object request) {
        Object response = webServiceTemplate.marshalSendAndReceive(request, new SoapActionCallback("http://thirdparty.com/webservice"));
        return response;
    }
}

在配置类中配置WebServiceTemplate：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.ws.client.core.WebServiceTemplate;

@Configuration
public class WebServiceConfig {

    @Bean
    public WebServiceTemplate webServiceTemplate() {
        WebServiceTemplate webServiceTemplate = new WebServiceTemplate();
        // 设置marshaller, unmarshaller等
        return webServiceTemplate;
    }
}

方式二：使用JAX-WS

首先需要添加JAX-WS依赖：

<dependency>
    <groupId>org.jvnet.jax-ws-commons.spring</groupId>
    <artifactId>jaxws-spring</artifactId>
    <version>1.9</version>
</dependency>

然后生成客户端代码，可以使用wsimport工具。

wsimport -keep -p com.example.client http://thirdparty.com/webservice?wsdl

生成客户端代码后，可以通过以下方式调用WebService：

import com.example.client.ThirdPartyService;
import com.example.client.ThirdPartyServiceSoap;

@Service
public class WebServiceClient {

    public Object callWebService(Object request) {
        ThirdPartyService service = new ThirdPartyService();
        ThirdPartyServiceSoap serviceSoap = service.getThirdPartyServiceSoap();
        Object response = serviceSoap.webMethod(request);
        return response;
    }
}

以上两种方式均可以在Spring Boot应用中调用第三方WebService接口。选择哪种方式取决于具体的项目需求和个人喜好。

- 阅读更多 -

Django之登录权限系统

System

2024-09-04

所有,数据库

以下是一个简化的Django登录和权限系统的示例代码。假设已经有了一个Django项目和应用。

首先，在models.py中定义用户模型和权限模型：

from django.db import models
from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    is_admin = models.BooleanField(default=False)

class UserPermission(models.Model):
    user = models.OneToOneField(CustomUser, on_delete=models.CASCADE)
    can_edit_data = models.BooleanField(default=False)

然后，在views.py中创建登录视图：

from django.contrib.auth import authenticate, login
from django.http import HttpResponse
from django.shortcuts import redirect

def custom_login(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            # 权限检查
            if user.is_admin:
                return redirect('admin_page')
            elif user.userpermission.can_edit_data:
                return redirect('edit_data_page')
            else:
                return redirect('user_page')
        else:
            return HttpResponse('Invalid login credentials')
    return redirect('login_page')

在urls.py中定义相应的URLs：

from django.urls import path
from .views import custom_login

urlpatterns = [
    path('login/', custom_login, name='login'),
    path('admin_page/', admin_view, name='admin_page'),
    path('user_page/', user_view, name='user_page'),
    path('edit_data_page/', edit_data_view, name='edit_data_page'),
]

确保在settings.py中设置了正确的AUTH\_USER\_MODEL：

AUTH_USER_MODEL = 'your_app_name.CustomUser'

这个简化的例子展示了如何在Django中实现一个基本的登录系统，并根据用户的权限将其重定向到不同的页面。在实际应用中，你可能需要使用更复杂的权限系统，比如Django的内置权限系统或者Django-guardian，以及更完善的登录表单和视图逻辑。

System

2024-09-04

所有,java

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

public class AuthGlobalFilter implements GlobalFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 从请求中获取Token
        String token = exchange.getRequest().getHeaders().getFirst("Token");

        // 验证Token是否存在，这里的逻辑需要根据实际情况来定制
        if (token == null || "".equals(token)) {
            // Token不存在，返回401 Unauthorized
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            // 可以返回JSON格式的错误信息
            return DataBufferUtils.write(response.bufferFactory(), "Token is missing", response.getBufferFactory().allocateBuffer().allocateBuffer())
                    .doOnNext(response.bufferFactory()::wrap);
        }

        // Token存在，继续向下执行
        return chain.filter(exchange);
    }
}

这段代码定义了一个全局过滤器，用于检查每个请求是否包含Token。如果Token不存在，则响应401 Unauthorized错误。这种方式可以用来保护微服务不受未授权的访问。

- 阅读更多 -

【效率翻倍神器】SpringBoot结合Redis打造高性能数据缓存解决方案

System

2024-09-04

所有,redis

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 存入缓存
    public void set(String key, Object value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    // 获取缓存
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    // 删除缓存
    public void delete(String key) {
        redisTemplate.delete(key);
    }
}

这段代码展示了如何在SpringBoot应用中使用RedisTemplate来实现简单的缓存操作。set方法用于将数据存入缓存，并设置过期时间；get方法用于从缓存中获取数据；delete方法用于删除缓存中的数据。这个示例展示了如何使用SpringBoot和Redis来提高应用的性能和响应速度。

- 阅读更多 -

Redis 作为向量数据库快速入门指南

System

2024-09-04

所有,redis

# 导入必要的包
import redis

# 连接到本地Redis实例
r = redis.Redis(host='localhost', port=6379, db=0)

# 设置键值对
r.set('key', 'value')

# 获取并打印键对应的值
value = r.get('key')
print(value)

# 列表操作
r.rpush('mylist', 'item1')
r.rpush('mylist', 'item2')
print(r.lrange('mylist', 0, -1))  # 打印列表所有元素

# 哈希操作
r.hset('myhash', 'field1', 'value1')
print(r.hgetall('myhash'))  # 打印哈希中的所有字段和值

# 集合操作
r.sadd('myset', 'member1')
r.sadd('myset', 'member2')
print(r.smembers('myset'))  # 打印集合中的所有成员

# 有序集合操作
r.zadd('myzset', {'member1': 1, 'member2': 2})
print(r.zrange('myzset', 0, -1, withscores=True))  # 打印有序集合中的所有成员和分数

这段代码展示了如何使用Python的redis包来连接到Redis数据库，并执行基本的键值对操作、列表操作、哈希操作、集合操作和有序集合操作。这是学习如何使用Redis作为数据存储的一个快速入门示例。

System

2024-09-04

所有,java

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

public class ModifyPathFilter implements GlobalFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 修改请求路径
        String newPath = "/newpath" + exchange.getRequest().getURI().getPath();
        ServerHttpRequest request = exchange.getRequest().mutate().path(newPath).build();
        // 注意：这里不能直接使用exchange.getRequest().mutate().path("/newpath")，因为这样会导致路径不正确

        // 由于ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR属性被用于内部，所以我们需要修改原始的url
        exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_ORIGINAL_REQUEST_URL_ATTR, request.getURI());

        return chain.filter(exchange.mutate().request(request).build());
    }
}

这段代码定义了一个名为ModifyPathFilter的全局过滤器，用于修改Spring Cloud Gateway请求的路径。它首先构建了一个新的请求，将原始路径追加到指定的前缀"/newpath"，然后将修改后的请求传递给过滤器链的下一个阶段。注意，我们还需要更新GATEWAY_ORIGINAL_REQUEST_URL_ATTR属性，以确保Gateway的其他部分不会因为这个修改而产生问题。

- 阅读更多 -

Oracle EBS 平均成本更新

System

2024-09-04

所有,数据库

在Oracle E-Business Suite中，更新物料的平均成本通常涉及到使用成本管理模块中的相关功能。以下是一个简化的例子，展示如何使用PL/SQL来更新物料的平均成本。

DECLARE
  v_inventory_item_id NUMBER := &your_inventory_item_id; -- 替换为你的物料编号
  v_cost_type_id       NUMBER := &your_cost_type_id;     -- 替换为你的成本类型编号
  v_period_name        VARCHAR2(30) := '&your_period_name'; -- 替换为你的会计期间名称
BEGIN
  -- 更新物料的平均成本
  UPDATE_ITEM_COSTS(
    p_api_version_number => 1.0,
    p_init_msg_list      => FND_API.G_FALSE,
    p_commit             => FND_API.G_FALSE,
    x_return_status      => NULL,
    x_msg_count          => NULL,
    x_msg_data           => NULL,
    p_inventory_item_id  => v_inventory_item_id,
    p_cost_type_id       => v_cost_type_id,
    p_period_name        => v_period_name,
    p_user_je_source_id  => NULL,
    p_user_je_source     => NULL,
    p_cost               => NULL,
    p_action             => 'UPDATE',
    p_action_comment     => 'Cost Updated via PL/SQL'
  );

  COMMIT; -- 确保事务被提交
EXCEPTION
  WHEN OTHERS THEN
    -- 异常处理逻辑
    DBMS_OUTPUT.PUT_LINE('Error Code: ' || SQLCODE);
    DBMS_OUTPUT.PUT_LINE('Error Message: ' || SQLERRM);
    ROLLBACK; -- 发生错误时回滚事务
END;
/

在这个PL/SQL块中，我们声明了必要的变量，并调用了UPDATE_ITEM_COSTS程序包提供的过程来更新物料的平均成本。这个过程需要你提供物料编号、成本类型编号和会计期间名称。p_action参数设置为'UPDATE'表示我们要更新成本，而p_action_comment参数可以用来添加一个注释，说明成本是如何被更新的。

请注意，在实际环境中，你需要有相应的权限来运行这段代码，并且确保所有的变量都是正确的。此外，代码中的&your_...占位符需要被替换为实际的值。

这个例子展示了如何使用PL/SQL来触发EBS中成本更新的过程，但具体的API参数和行为可能会根据EBS版本的不同而有所差异。如果你在实际操作中遇到问题，请参考你所使用EBS版本的官方文档。

- 阅读更多 -

Laravel 分页：增加 URL 参数

System

2024-09-04

所有,php

在 Laravel 中，分页链接默认会附加页码作为 URL 参数。如果你需要在分页链接中添加额外的 URL 参数，你可以使用 withQueryString 方法。

例如，你想在分页时保持当前的搜索词或过滤条件，可以这样做：

// 假设你已经有了一个名为 $items 的分页集合，并且你想要添加一个名为 'filter' 的 URL 参数

// 假设你的当前 URL 是 http://example.com/items?page=2

// 使用 withQueryString 方法添加额外的参数
$items->withQueryString()->links();

// 这将生成带有额外查询字符串参数的分页链接，如下：
// 上一页: <a href="http://example.com/items?page=1&filter=value">1</a>
// 下一页: <a href="http://example.com/items?page=3&filter=value">3</a>

在控制器中，你可以这样获取参数：

public function index(Request $request)
{
    $filter = $request->query('filter');
    $items = Item::where('some_column', $filter)->paginate(10);
    // 然后返回视图，并传递 $items
}

确保在视图文件中渲染分页链接时使用 $items->withQueryString()。这样，当用户点击分页链接时，你添加的 URL 参数 'filter' 会被保留。

- 阅读更多 -

Spring Boot 集成 swagger 3.0 指南

System

2024-09-04

所有,java

import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SwaggerConfig {

    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
                .info(new Info()
                        .title("示例应用 API")
                        .description("这是一个简单的示例应用程序的 API 文档")
                        .version("1.0.0")
                        .license(new License().name("Apache 2.0").url("http://springdoc.org")))
                .termsOfService("http://springdoc.org")
                .contact(new io.swagger.v3.oas.models.info.Contact()
                        .email("dev@email.com"))
                ;
    }
}

这段代码定义了一个配置类，其中包含了一个自定义的OpenAPI bean。这个bean被用来配置swagger的API文档的基本信息，包括标题、描述、版本、许可证信息和服务条款。这是一个简单的示例，实际使用时可以根据项目需要进行更多的配置。

- 阅读更多 -

如何保证MySQl和Redis的数据一致性？缓存更新策略

System

2024-09-04

所有,redis

为了保证MySQL和Redis之间的数据一致性，可以采用以下策略：

写入MySQL后更新Redis：在数据写入MySQL后，同步更新Redis。
删除Redis缓存：数据在MySQL更新时，删除对应的Redis缓存。

以下是更新MySQL和Redis的示例代码：

import redis
import pymysql

# 连接Redis
r = redis.StrictRedis(host='localhost', port=6379, db=0)

# 连接MySQL
conn = pymysql.connect(host='localhost', user='user', password='passwd', db='db', charset='utf8mb4')

# 更新MySQL
def update_mysql(data):
    with conn.cursor() as cursor:
        sql = "UPDATE table SET column = %s WHERE id = %s"
        cursor.execute(sql, (data['value'], data['id']))
        conn.commit()

# 更新Redis
def update_redis(data):
    r.set(f"key:{data['id']}", data['value'])

# 更新数据示例
data = {'id': 1, 'value': 'new_value'}
update_mysql(data)
update_redis(data)

在删除操作中，同样先删除MySQL数据，然后删除对应的Redis缓存：

# 删除MySQL数据
def delete_from_mysql(id):
    with conn.cursor() as cursor:
        sql = "DELETE FROM table WHERE id = %s"
        cursor.execute(sql, (id,))
        conn.commit()

# 删除Redis缓存
def delete_from_redis(id):
    r.delete(f"key:{id}")

# 删除数据示例
id_to_delete = 1
delete_from_mysql(id_to_delete)
delete_from_redis(id_to_delete)

为了保证数据的一致性，在并发操作时可能需要额外的锁机制来同步。

- 阅读更多 -

方式一：使用WebServiceTemplate

方式二：使用JAX-WS

方式一：使用`WebServiceTemplate`