分类后端技术下的文章

2024-08-30

MySQL是一个开源的关系型数据库管理系统，被广泛应用于各种Web应用程序中。以下是MySQL的简单介绍和对数据库基本操作的示例代码。

简介：

MySQL是一个关系型数据库管理系统，特别适合Web应用。
MySQL是开源的，所以它的成本低，提供了强大的性能。
MySQL支持标准的SQL语言，并提供了Python，PHP，Java，C#等多种语言的API。

操作示例：

连接到MySQL数据库：




import mysql.connector
 
# 连接到数据库
db = mysql.connector.connect(
  host="localhost",
  user="yourusername",
  password="yourpassword",
  database="mydatabase"
)
 
# 创建一个cursor对象
cursor = db.cursor()
 
# 关闭数据库连接
db.close()

创建一个新的数据库：




CREATE DATABASE mydatabase;

选择一个数据库：




cursor.execute("USE mydatabase;")

创建一个数据表：




CREATE TABLE mytable(
  id INT AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(255),
  age INT
);

插入数据：




INSERT INTO mytable(name, age) VALUES ("Alice", 25);

查询数据：




SELECT * FROM mytable;

更新数据：




UPDATE mytable SET age = 26 WHERE name = "Alice";

删除数据：




DELETE FROM mytable WHERE name = "Alice";

删除数据表：




DROP TABLE mytable;

删除数据库：




DROP DATABASE mydatabase;

以上操作需要在连接到MySQL数据库后进行，并在操作完成后关闭数据库连接。这些操作涵盖了数据库的基本管理，包括创建、选择、插入、查询、更新和删除数据，以及创建和删除数据库和数据表。

2024-08-30

所有,redis

解释：

这个错误信息表明在使用 Redis 的 redis.call 或 redis.pcall 函数时，第一个参数必须是一个单个的字面字符串，也就是说，这个字符串必须是一个常量，不能是一个变量或者复杂的表达式。

redis.call 和 redis.pcall 是在 Redis 的 Lua 脚本中使用的函数，用于执行 Redis 命令。第一个参数通常是要执行的 Redis 命令的名称，例如 "GET"、"SET" 等。

解决方法：

确保你传递给 redis.call 或 redis.pcall 的第一个参数是一个单引号括起来的字符串，并且这个字符串是一个命令的名称，例如：




redis.call('GET', 'mykey')

而不是：




redis.call(command_name, 'mykey')  -- 错误，因为 command_name 可能是一个变量

如果你需要动态地构建命令名称，你可以这样做：




local command_name = 'GET'
redis.call(command_name .. ' mykey')  -- 错误，因为命令名称将是 "GET mykey"

正确的做法是直接使用字面字符串：




redis.call('GET', 'mykey')  -- 正确

如果你需要根据条件构建不同的命令，你可以这样做：




local command = someCondition and 'GET' or 'SET'
redis.call(command, 'mykey')  -- 正确，因为 command 是一个字面字符串

总之，确保 redis.call 或 redis.pcall 的第一个参数始终是一个单引号括起来的字符串。

Spring Cloud项目如何防止重复提交（自定义注解）

2024-08-30

所有,java

在Spring Cloud项目中，防止重复提交可以通过自定义注解和拦截器实现。以下是一个简单的示例：

自定义注解 @NoRepeatSubmit：




@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NoRepeatSubmit {
    long timeout() default 5000; // 超时时间，单位毫秒，默认5秒内禁止重复提交
}

创建一个拦截器 NoRepeatSubmitInterceptor：




@Component
public class NoRepeatSubmitInterceptor implements HandlerInterceptor {
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            NoRepeatSubmit noRepeatSubmit = method.getAnnotation(NoRepeatSubmit.class);
            if (noRepeatSubmit != null) {
                // 获取请求的唯一标识
                String token = request.getHeader("token");
                if (token == null) {
                    token = request.getParameter("token");
                }
                if (token == null) {
                    throw new RuntimeException("无法获取请求标识，无法检查重复提交");
                }
                // 根据token检查是否重复提交
                boolean isRepeat = checkIfRepeat(token, noRepeatSubmit.timeout());
                if (isRepeat) {
                    response.setContentType("application/json;charset=UTF-8");
                    response.getWriter().write("{\"code\":\"400\",\"message\":\"请勿重复提交\"}");
                    return false;
                }
                // 没有重复提交，保存token
                saveToken(token, noRepeatSubmit.timeout());
            }
        }
        return true;
    }
 
    // 模拟检查是否重复提交的方法
    private boolean checkIfRepeat(String token, long timeout) {
        // 实现逻辑，根据token和超时时间判断是否重复提交
        return false; // 假设没有重复提交
    }
 
    // 模拟保存token的方法
    private void saveToken(String token, long timeout) {
        // 实现逻辑，保存token至缓存，并设置超时时间
    }
}

注册拦截器，在配置类中添加拦截器注册：




@Configuration
public class WebConfig implements WebMvcConfigurer {
 
    @Autowired
    private NoRepeatSubmitInterceptor noRepeatSubmitInterceptor;
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(noRepeatSubmitInterceptor)
                .addPathPatterns("/**"); // 拦截所有路径
    }
}

使用自定义注解：




@RestController
public class YourContro

在 PostgreSQL 里如何实现数据的自动清理和过期处理？

2024-08-30

在PostgreSQL中，可以使用DROP TABLE语句来删除整个表，或者使用DELETE语句来删除特定行。如果需要根据数据的年龄自动删除数据，可以使用存储过程定时执行删除操作，或者使用事务调度器如pg_cron或pgAgent（在PostgreSQL之外）。

以下是一个使用存储过程和pg_cron来定期删除过期数据的例子：

首先，确保你的PostgreSQL服务器安装并启用了pg_cron扩展。
创建一个存储过程，它将删除过期的数据。




CREATE OR REPLACE FUNCTION cleanup_data() RETURNS void AS $$
BEGIN
    -- 假设有一个名为my_table的表，有一个timestamp类型的列named created_at
    -- 删除所有在30天前创建的数据
    DELETE FROM my_table WHERE created_at < now() - interval '30 days';
    RAISE NOTICE 'Data cleaned up successfully';
END;
$$ LANGUAGE plpgsql;

使用pg_cron定时调用这个函数。例如，每天午夜调用一次：




SELECT pg_cron.schedule('0 0 * * *', $$SELECT cleanup_data()$$);

请注意，pg_cron扩展不是PostgreSQL的标准部分，你可能需要单独安装它。

如果你不能使用pg_cron，可以考虑使用操作系统的定时任务（如cron作业）来触发一个执行相同操作的SQL脚本。

探索Django：从项目创建到图片上传的全方位指南

2024-08-30




from django.shortcuts import render
from django.http import HttpResponse
from .models import Post
from .forms import PostForm
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_POST
from django.http import JsonResponse
import os
 
# 创建一个新的帖子
@login_required
@require_POST
def create_post(request):
    form = PostForm(request.POST, request.FILES)
    if form.is_valid():
        post = form.save(commit=False)
        post.user = request.user
        post.save()
        return JsonResponse({'id': post.id})
    return JsonResponse({'error': 'Invalid data'}, status=400)
 
# 图片上传视图
@login_required
@require_POST
def upload_image(request):
    image = request.FILES['image']
    image_name = os.path.join('posts', image.name)
    with open(image_name, 'wb+') as destination:
        for chunk in image.chunks():
            destination.write(chunk)
    return JsonResponse({'image_url': image_name})
 
# 展示创建帖子的表单
@login_required
def create_post_form(request):
    if request.method == 'POST':
        # 处理POST请求
        return create_post(request)
    else:
        # 显示空表单
        return render(request, 'posts/create_post.html', {'form': PostForm()})
 
# 展示上传图片的表单
@login_required
def upload_image_form(request):
    if request.method == 'POST' and 'image' in request.FILES:
        # 处理POST请求和图片上传
        return upload_image(request)
    else:
        # 显示空表单或错误信息
        return render(request, 'posts/upload_image.html')

在这个示例中，我们创建了两个视图函数create_post和upload_image来处理帖子创建和图片上传的逻辑。这两个视图函数都使用了Django的装饰器login_required和require_POST来确保只有登录用户可以访问，并且只处理HTTP POST请求。另外，我们使用了JsonResponse来返回JSON格式的响应，这是一种常见的AJAX请求处理方式。

2024-08-30

在Python中，可以使用各种库来连接和操作不同类型的数据库，如MSSQL, MySQL, SQLite, Redis, ElasticSearch, MongoDB, PostgreSQL 和 Oracle。以下是一些示例代码：

连接MSSQL:




import pymssql
 
conn = pymssql.connect(server='your_server', user='your_username', password='your_password', database='your_database')
cursor = conn.cursor()
cursor.execute("SELECT * FROM your_table")
row = cursor.fetchone()
while row:
    print(row)
    row = cursor.fetchone()
 
conn.close()

连接MySQL:




import mysql.connector
 
conn = mysql.connector.connect(host='your_host', user='your_username', password='your_password', database='your_database')
cursor = conn.cursor()
cursor.execute("SELECT * FROM your_table")
row = cursor.fetchone()
while row:
    print(row)
    row = cursor.fetchone()
 
conn.close()

连接SQLite:




import sqlite3
 
conn = sqlite3.connect('your_database.db')
cursor = conn.cursor()
cursor.execute("SELECT * FROM your_table")
row = cursor.fetchone()
while row:
    print(row)
    row = cursor.fetchone()
 
conn.close()

连接Redis:




import redis
 
r = redis.Redis(host='your_host', port=your_port, db=your_db)
value = r.get('your_key')
print(value)

连接ElasticSearch:




from elasticsearch import Elasticsearch
 
es = Elasticsearch(hosts=['your_host'])
response = es.search(index='your_index', body={'query': {'match_all': {}}})
print(response)

连接MongoDB:




from pymongo import MongoClient
 
client = MongoClient('mongodb://your_username:your_password@your_host:your_port/your_database')
db = client['your_database']
collection = db['your_collection']
document = collection.find_one()
print(document)

连接PostgreSQL:




import psycopg2
 
conn = psycopg2.connect(dbname='your_dbname', user='your_user', password='your_pw', host='your_host', port='your_port')
cursor = conn.cursor()
cursor.execute("SELECT * FROM your_table")
row = cursor.fetchone()
while row:
    print(row)
    row = cursor.fetchone()
 
conn.close()

连接Oracle:




import cx_Oracle
 
conn =

sql常用语句及其调优

2024-08-30

SQL常用语句和调优是一个非常广泛的话题，这里我提供一些基本的SQL查询和调优技巧的例子：

查询语句：




-- 查询表中所有数据
SELECT * FROM table_name;
 
-- 查询指定列的数据
SELECT column1, column2 FROM table_name;
 
-- 带条件的查询
SELECT * FROM table_name WHERE condition;
 
-- 排序查询结果
SELECT * FROM table_name ORDER BY column ASC|DESC;
 
-- 聚合查询
SELECT COUNT(*), SUM(column), AVG(column) FROM table_name;
 
-- 分组查询
SELECT column, COUNT(*) FROM table_name GROUP BY column;
 
-- 连接查询
SELECT * FROM table1 JOIN table2 ON table1.column_name = table2.column_name;

调优技巧：

使用索引：为常查询的列创建索引可以提高查询速度。
避免SELECT *：只选择需要的列，减少网络传输和服务器处理的数据量。
使用WHERE子句：过滤不需要的数据，减少返回的数据行数。
使用连接代替子查询：连接查询通常比子查询更高效。
使用合适的JOIN类型：INNER JOIN、LEFT JOIN、RIGHT JOIN等。
优化GROUP BY和ORDER BY：确保使用合适的列和索引来减少分组和排序的时间。
分批处理数据：对大量数据进行操作时，可以分批处理以减少影响。
使用EXPLAIN分析查询：了解数据库如何处理查询，并根据分析结果进行调优。

这些是SQL调优的基础，根据实际情况可能需要更复杂的调优策略。

2024-08-30

所有,java

创建自定义Spring Boot Starter的步骤概括如下：

创建一个新的Maven项目作为Starter。
添加Spring Boot的依赖。
编写自动配置类并注解@Configuration。
在资源目录META-INF下创建spring.factories文件，指定自动配置的类。
打包并发布Starter。

以下是一个简单的自定义Starter的示例：

pom.xml




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

MyAutoConfiguration.java




import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@EnableAutoConfiguration
public class MyAutoConfiguration {
 
    @Bean
    public MyService myService() {
        return new MyService();
    }
}
 
class MyService {
    // ...
}

在resources/META-INF目录下创建spring.factories文件：




org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.example.MyAutoConfiguration

这样，你就创建了一个简单的自定义Spring Boot Starter，它提供了一个名为MyService的Bean。开发者在引入这个Starter后，MyService将自动配置并可以注入到Spring应用上下文中。

基于springboot+vue的小徐影城管理系统(前后端分离)

2024-08-30

所有,java

小徐影城管理系统是一个使用Spring Boot和Vue.js进行前后端分离开发的电影票预订管理系统。由于这个项目涉及的代码量较大，我无法在一篇文章中提供全部代码。但我可以提供一些核心组件的代码示例。

用户登录（Spring Boot后端）：




@RestController
@RequestMapping("/api/auth")
public class AuthController {
    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody LoginRequest loginRequest) {
        try {
            Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword())
            );
            SecurityContextHolder.getContext().setAuthentication(authentication);
            String jwt = tokenProvider.generateToken(authentication);
            return ResponseEntity.ok(new JwtAuthenticationResponse(jwt));
        } catch (AuthenticationException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(new MessageResponse("Authentication failed: " + e.getMessage()));
        }
    }
}

获取电影列表（Spring Boot后端）：




@RestController
@RequestMapping("/api/movies")
public class MovieController {
    @GetMapping
    public ResponseEntity<List<MovieDto>> getAllMovies() {
        List<Movie> movies = movieService.findAll();
        List<MovieDto> movieDtos = movies.stream()
            .map(movie -> modelMapper.map(movie, MovieDto.class))
            .collect(Collectors.toList());
        return ResponseEntity.ok(movieDtos);
    }
}

电影列表页面（Vue前端）：




<template>
  <div>
    <h1>电影列表</h1>
    <div v-for="movie in movies" :key="movie.id">
      {{ movie.name }}
    </div>
  </div>
</template>
 
<script>
export default {
  data() {
    return {
      movies: []
    };
  },
  created() {
    this.fetchMovies();
  },
  methods: {
    fetchMovies() {
      this.axios.get('/api/movies')
        .then(response => {
          this.movies = response.data;
        })
        .catch(error => {
          console.error('There was an error!', error);
        });
    }
  }
};
</script>

这些代码片段展示了如何使用Spring Boot和Vue.js创建一个简单的后端API和前端页面，用户可以登录并获取电影列表。实际项目中，你需要实现完整的用户注册、密码重置、权限验证、分页、错误处理等功能。

由于篇幅限制，这里不可能提供完整的项目代码。如果你需要这个项目的完整代码，你可能需要联系原作者或者通过相关的教育课程进行学习。

Linux centos7系统下安装postgresql和远程访问设置

2024-08-30

在CentOS 7上安装PostgreSQL并设置远程访问的步骤如下：

添加PostgreSQL的Yum仓库：




sudo yum install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm

安装PostgreSQL：




sudo yum install -y postgresql12-server

初始化数据库：




sudo /usr/pgsql-12/bin/postgresql-12-setup initdb

启动并使PostgreSQL服务开机自启：




sudo systemctl enable postgresql-12
sudo systemctl start postgresql-12

登录到PostgreSQL：




sudo -i -u postgres
psql

设置PostgreSQL允许远程连接：
在postgresql.conf文件中设置listen_addresses和port：




ALTER SYSTEM SET listen_addresses = '*' ;
ALTER SYSTEM SET port = 5432 ;

创建允许远程连接的用户：




CREATE ROLE dbuser WITH LOGIN PASSWORD 'dbpassword';

创建数据库并授权：




CREATE DATABASE mydatabase;
GRANT ALL PRIVILEGES ON DATABASE mydatabase TO dbuser;

重载PostgreSQL配置并退出：




SELECT pg_reload_conf();
\q

修改防火墙规则允许远程访问：




sudo firewall-cmd --permanent --zone=public --add-service=postgresql
sudo firewall-cmd --reload

测试远程连接：
使用如psql、pgAdmin或其他数据库工具尝试远程连接到你的PostgreSQL服务器。

请根据实际情况替换dbuser、dbpassword和mydatabase为你的实际用户名、密码和数据库名。