1. 首页
  2. 分类
  3. 后端技术
Django学习笔记：基于Django+sqlite简单实现学生信息管理系统（注册、登录、增删改查
System
2024-09-03
所有,数据库



# 导入Django模块
import os
from django.shortcuts import render
from django.http import HttpResponse
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from .models import Student
 
# 首页视图
def index(request):
    return render(request, 'students/index.html')
 
# 登录视图
def user_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)
            return HttpResponse("登录成功")
        else:
            return HttpResponse("用户名或密码错误")
    else:
        return render(request, 'students/login.html')
 
# 注册视图
def register(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = User.objects.create_user(username=username, password=password)
        return HttpResponse("注册成功")
    else:
        return render(request, 'students/register.html')
 
# 登出视图
def user_logout(request):
    logout(request)
    return HttpResponse("登出成功")
 
# 学生信息视图
@login_required
def students(request):
    students = Student.objects.all()
    return render(request, 'students/students.html', {'students': students})
 
# 添加学生信息视图
@login_required
def add_student(request):
    if request.method == 'POST':
        name = request.POST['name']
        age = request.POST['age']
        gender = request.POST['gender']
        address = request.POST['address']
        Student.objects.create(name=name, age=age, gender=gender, address=address)
        return HttpResponse("添加成功")
    else:
        return render(request, 'students/add_student.html')
 
# 删除学生信息视图
@login_required
def delete_student(request, pk):
    Student.objects.filter(id=pk).delete()
    return HttpResponse("删除成功")
 
# 更新学生信息视图
@login_required
def update_student(request, pk):
    if request.method == 'POST':
        name = request.POST['name']
        age = request.POST['age']
        gender = request.POST['gender']
        address = request.POST['address']
        Student.objects.filter(id=pk).update(name=name, age=age, gende
- 阅读更多 -
【KivyMD 应用程序 1.1.1】MDBackdrop back_layer_color 背景层颜色
System
2024-09-03
所有,数据库

在KivyMD中，MDBackdrop是一个控件，用于创建背景层，可以在其上放置内容。MDBackdrop的back_layer_color属性用于设置背景层的颜色。

以下是如何设置MDBackdrop的back_layer_color属性的示例代码：




from kivymd.app import MDApp
from kivy.lang import Builder
 
KV_CODE = """
MDBackdrop:
    back_layer_color: app.theme_cls.primary_color
    # 其他代码...
"""
 
class TestApp(MDApp):
    def build(self):
        return Builder.load_string(KV_CODE)
 
TestApp().run()

在这个例子中，我们使用了Builder.load\_string()方法来加载KV语言编写的GUI定义。MDBackdrop的back_layer_color被设置为应用程序主题类的primary\_color。你可以根据需要更改为其他颜色值，例如使用RGBA格式：




back_layer_color: 0, 0, 1, 1  # 蓝色，透明度为1

确保在设置颜色时使用正确的颜色格式和值。

- 阅读更多 -
Redis——缓存穿透、击穿、雪崩、双写一致性、持久化、数据淘汰策略、数据删除、分布式锁
System
2024-09-03
所有,redis

问题描述的是Redis缓存问题的一些典型情况，包括缓存穿透、击穿、雪崩、双写一致性、持久化、数据淘汰策略和数据删除。以下是对这些问题的简要解释和解决方案：

  1. 缓存穿透：

    问题：查询不存在的数据，缓存和数据库都没有，导致每次请求都会打到数据库上。

    解决方案：使用布隆过滤器或者缓存空对象。

  2. 缓存击穿：

    问题：一个Key同时大量并发请求，该Key正好过期，导致大量请求打到数据库。

    解决方案：设置热点Key的过期时间随机化，或使用分布式锁。

  3. 雪崩：

    问题：大量Key同时过期，导致数据库压力剧增。

    解决方案：不同的Key设置不同的过期时间，或者使用相同的过期时间并加上随机值，避免大量Key在同一时间过期。

  4. 双写一致性：

    问题：在数据更新时，数据库和缓存更新成功，但是因为某种原因（如网络问题）导致更新不一致。

    解决方案：使用事务或锁保证操作的原子性，或使用消息队列异步通知更新缓存。

  5. 持久化：

    问题：数据丢失。

    解决方案：使用RDB或AOF进行数据持久化。

  6. 数据淘汰策略：

    问题：内存不足，需要淘汰数据。

    解决方案：使用LRU、LFU等淘汰策略。

  7. 数据删除：

    问题：数据删除后如何处理。

    解决方案：通过删除指令删除缓存数据，并确保数据库数据也被删除。

以上是对这些问题的简要解释和解决方案，具体实施时需要根据实际情况进行调整。

- 阅读更多 -
spring 5.3.x 、6.1.x、6.0.x 源码本地编译运行
System
2024-09-03
所有,java

要在本地编译和运行Spring 5.3.x、6.1.x或6.0.x的源码，你需要执行以下步骤：

  1. 确保你的开发环境满足Spring源码的编译要求，包括：

    • Java Development Kit (JDK) 11或更高版本
    • Git
    • Maven 3.6.x或更高版本

  2. 克隆对应的Spring版本的源码仓库：

    


git clone -b <branch_name> https://github.com/spring-projects/spring-framework.git

    其中<branch_name>替换为你想要编译的Spring版本的分支名，例如：

    • 对于Spring 5.3.x，分支名可能是5.3.x
    • 对于Spring 6.1.x，分支名可能是6.1.x
    • 对于Spring 6.0.x，分支名可能是6.0.x

  3. 进入克隆的仓库目录：

    


cd spring-framework

  4. 运行Maven命令来编译和安装Spring源码：

    


./mvnw clean install

  5. 编译完成后，你可以运行Spring的单元测试来验证编译结果：

    


./mvnw test

  6. 如果你想要在IDE中开发和调试，你可以使用Maven导入项目到你的IDE中，例如IntelliJ IDEA：

    


./mvnw idea:idea

    然后在IntelliJ IDEA中打开项目。

以上步骤会在本地编译和安装Spring源码，允许你运行和调试最新的Spring版本。

- 阅读更多 -
Oracle中表或视图不存在自动创建
System
2024-09-03
所有,数据库

在Oracle中，如果你想要在表或视图不存在时自动创建它们，你可以使用PL/SQL的异常处理机制来实现。以下是一个简单的PL/SQL块示例，它尝试创建一个表，如果表不存在则捕获异常并创建它：




DECLARE
    e_table_does_not_exist EXCEPTION;
    PRAGMA EXCEPTION_INIT(e_table_does_not_exist, -942);
BEGIN
    EXECUTE IMMEDIATE 'CREATE TABLE my_table (id NUMBER, name VARCHAR2(100))';
EXCEPTION
    WHEN e_table_does_not_exist THEN
        NULL; -- 已存在，不需要处理异常
    WHEN OTHERS THEN
        -- 处理其他潜在的异常
        RAISE;
END;

在这个例子中，我们声明了一个异常e_table_does_not_exist，并使用PRAGMA将Oracle的系统错误代码-942与该异常关联，这个错误代表表或视图不存在的错误。然后，我们尝试创建表，并捕获这个特定的异常。如果异常发生（表不存在），我们不采取任何行动；如果抛出其他异常（例如权限问题或语法错误），则通过RAISE重新抛出异常。

- 阅读更多 -
Spring Boot整合MyBatis-Flex
System
2024-09-03
所有,java

Spring Boot整合MyBatis-Flex不是一个常见的组合，因为MyBatis-Flex是一个专门为NoSQL数据库（如MongoDB）提供的灵活查询插件，并不直接支持SQL数据库如MySQL或PostgreSQL。

如果你想在Spring Boot应用中使用MyBatis访问MongoDB，你可以按照以下步骤操作：

  1. 在pom.xml中添加MyBatis-Flex依赖和Spring Boot的MongoDB依赖。



<dependencies>
    <!-- Spring Boot相关依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <!-- MyBatis-Flex依赖 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>版本号</version>
    </dependency>
</dependencies>
  1. 配置application.properties或application.yml文件，包含MongoDB的连接信息。



spring.data.mongodb.uri=mongodb://username:password@localhost:27017/yourdb
  1. 创建一个Mapper接口，使用MyBatis-Flex的注解定义查询。



import org.apache.ibatis.annotations.Select;
import org.mybatis.spring.annotation.Mapper;
import org.mybatis.flex.query.MongoQuery;
import org.springframework.data.mongodb.repository.MongoRepository;
 
@Mapper
public interface YourEntityMapper {
    @Select(MongoQuery.select("*").from("your_collection"))
    List<YourEntity> findAll();
}
  1. 在Spring Boot的主类或配置类中配置MyBatis-Flex。



import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@MapperScan(basePackages = "你的Mapper包路径")
public class MyBatisConfig {
}
  1. 使用Mapper进行数据库操作。



import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service
public class YourService {
    @Autowired
    private YourEntityMapper mapper;
 
    public List<YourEntity> getAll() {
        return mapper.findAll();
    }
}

请注意，上述代码是基于MyBatis-Flex和Spring Boot的概念性示例，并不是实际可以运行的代码。你需要根据自己的项目需求和数据库结构进行调整。如果你是要整合MyBatis访问MySQL或PostgreSQL，你应该使用MyBatis的正常SQL映射配置，而不是MyBatis-Flex。

- 阅读更多 -
【微服务】SpringClound常用注解以及示例
System
2024-09-03
所有,java

Spring Cloud 是一系列框架的有序集合，用于快速构建分布式系统中的配置管理、服务发现、断路器、智能路由、微代理、控制总线等内容。

以下是Spring Cloud中一些常用的注解和简单示例：

  1. @EnableEurekaClient 或 @EnableEurekaServer：启用Eureka客户端或服务端功能。

    Eureka客户端示例：

    


@SpringBootApplication
@EnableEurekaClient
public class Application {
    // ...
}

    Eureka服务端示例：

    


@SpringBootApplication
@EnableEurekaServer
public class Application {
    // ...
}

  2. @EnableCircuitBreaker：启用断路器功能。

    使用Hystrix断路器的示例：

    


@SpringBootApplication
@EnableCircuitBreaker
public class Application {
    // ...
}

  3. @EnableFeignClients：启用Feign客户端功能。

    Feign客户端示例：

    


@SpringBootApplication
@EnableFeignClients(basePackages = "com.example.clients")
public class Application {
    // ...
}

  4. @EnableZuulProxy：启用Zuul路由代理功能。

    Zuul代理示例：

    


@SpringBootApplication
@EnableZuulProxy
public class Application {
    // ...
}

  5. @EnableConfigServer：启用配置服务器功能。

    配置服务器示例：

    


@SpringBootApplication
@EnableConfigServer
public class Application {
    // ...
}

  6. @EnableDiscoveryClient：启用服务发现客户端功能。

    服务发现客户端示例：

    


@SpringBootApplication
@EnableDiscoveryClient
public class Application {
    // ...
}

  7. @HystrixCommand：标记方法为Hystrix命令，用于服务降级和熔断。

    Hystrix命令示例：

    


@Service
public class MyService {
    @HystrixCommand(fallbackMethod = "fallbackMethod")
    public String execute() {
        // 业务逻辑
    }
 
    public String fallbackMethod() {
        // 降级逻辑
    }
}

  8. @FeignClient：用于定义Feign客户端。

    Feign客户端示例：

    


@FeignClient(name = "serviceName", url = "http://localhost:8080")
public interface MyFeignClient {
    @GetMapping("/endpoint")
    String getData();
}

这些注解和示例代表了Spring Cloud中的核心概念和用法。在实际应用中，你需要根据具体需求选择合适的注解，并配置相应的参数。

- 阅读更多 -
网关 Spring Cloud Zuul 常见功能介绍（翻译）
System
2024-09-03
所有,java

Zuul是Netflix开源的一个API网关，它可以与Spring Cloud集成，提供路由，过滤，服务发现和负载均衡等功能。

以下是Zuul的一些常见功能：

  1. 路由功能：Zuul可以将请求转发到具体的服务实例上。例如，所有到"/api-a/"的请求可以被转发到服务"service-a"上，所有到"/api-b/"的请求可以被转发到服务"service-b"上。
  2. 过滤器：Zuul中的过滤器可以在请求被路由前后修改请求的内容。例如，可以实现一个过滤器进行权限校验，或者在请求被路由后修改响应数据等。
  3. 服务发现和负载均衡：Zuul可以与Eureka等服务发现组件集成，可以通过服务发现来查找可用的服务实例，并实现负载均衡。
  4. 健康检查：Zuul可以与Ribbon等组件集成，可以提供边缘层的健康检查，避免将请求转发到非健康的服务实例上。
  5. 动态路由：Zuul可以配置动态路由，不需要在配置文件中静态指定所有的路由规则。
  6. 身份验证和授权：Zuul可以用来实现身份验证和授权，只有通过验证的请求才会被转发。
  7. 压力测试：Zuul可以用来记录每个服务的请求量，以便于分析系统的负载。
  8. 实时统计和监控：Zuul可以用来实时统计各种指标，如响应时间，响应码等，以便于监控系统的运行状态。

以下是一个简单的使用Zuul的例子：




@SpringBootApplication
@EnableZuulProxy
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

在上述例子中，我们创建了一个Spring Boot应用程序，并使用@EnableZuulProxy注解启用了Zuul作为API网关。然后，我们可以通过配置文件来定义路由规则，例如：




zuul:
  routes:
    service-a:
      path: /service-a/**
      url: http://service-a
    service-b:
      path: /service-b/**
      url: http://service-b

在这个配置中，所有到"/service-a/"的请求都会被转发到服务"service-a"，所有到"/service-b/"的请求都会被转发到服务"service-b"。这样，Zuul就作为一个API网关，提供了路由转发的功能。

- 阅读更多 -
Android学习：两个Activity如何操作同一个数据库SQLite
System
2024-09-03
所有,数据库

在Android中，两个Activity可以通过ContentProvider或者将数据库封装在一个Repository类中来共享同一个数据库。以下是使用Room库操作同一个数据库的简单示例：

  1. 定义数据实体和数据库接口：



// User.java
@Entity
public class User {
    @PrimaryKey
    private int id;
    private String name;
    // getters and setters
}
 
// UserDao.java
@Dao
public interface UserDao {
    @Query("SELECT * FROM user")
    List<User> getAll();
 
    @Query("SELECT * FROM user WHERE id = :id")
    User getUserById(int id);
 
    @Insert
    void insertUser(User user);
 
    @Update
    void updateUser(User user);
 
    @Delete
    void deleteUser(User user);
}
 
// AppDatabase.java
@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}
  1. 在Application类中初始化数据库：



// MyApplication.java
public class MyApplication extends Application {
    private static AppDatabase db;
 
    @Override
    public void onCreate() {
        super.onCreate();
        db = Room.databaseBuilder(getApplicationContext(), AppDatabase.class, "my_database")
                .build();
    }
 
    public static AppDatabase getDatabase() {
        return db;
    }
}
  1. 在Activity中使用数据库：



// Activity1.java
public class Activity1 extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // ...
 
        UserDao userDao = MyApplication.getDatabase().userDao();
        User user = new User();
        user.setName("Alice");
        userDao.insertUser(user);
    }
}
 
// Activity2.java
public class Activity2 extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // ...
 
        UserDao userDao = MyApplication.getDatabase().userDao();
        List<User> users = userDao.getAll();
        // 使用获取到的用户数据
    }
}

确保在AndroidManifest.xml中配置了MyApplication类：




<application
    android:name=".MyApplication"
    ...>
    <!-- activities and other components -->
</application>

这样，两个Activity都可以通过MyApplication.getDatabase().userDao()来访问同一个数据库并操作用户数据。

- 阅读更多 -
前后端分离(Vue+SpringBoot)项目部署云服务器
System
2024-09-03
所有,java

前后端分离项目部署到云服务器的步骤大致如下：

  1. 本地构建前端Vue项目：

    在Vue项目根目录下运行构建命令：

    


npm run build

    构建完成后，会生成一个dist目录，里面包含了前端的静态文件。

  2. 打包后端Spring Boot项目：

    使用Maven或Gradle打包你的Spring Boot项目：

    


mvn clean package

    或

    


gradlew build

    打包完成后，会生成一个jar或war文件。

  3. 云服务器配置：

    购买云服务器，如AWS EC2, Azure VM, 腾讯云CVM等，并配置安全组，开放必要的端口（如HTTP 80/HTTPS 443, SSH 22等）。

  4. 上传文件到服务器：

    使用SCP或FTP工具将前端的dist目录和后端的jar/war文件上传到服务器。

  5. 部署后端应用：

    通过SSH连接到服务器，运行Spring Boot应用：

    


java -jar your-application.jar

    或者使用nohup或screen使应用在后台运行：

    


nohup java -jar your-application.jar &

  6. 部署前端应用：

    将前端静态文件部署在服务器的web服务器上，如Nginx。假设你的服务器IP是1.2.3.4，编辑Nginx配置文件（通常位于/etc/nginx/sites-available/default），将静态文件指向/path/to/dist目录：

    


server {
    listen 80;
    server_name 1.2.3.4;
 
    location / {
        root /path/to/dist;
        try_files $uri $uri/ /index.html;
    }
 
    location /api/ {
        proxy_pass http://1.2.3.4:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

    然后重启Nginx：

    


sudo systemctl restart nginx

  7. 配置域名：

    购买域名，并在域名管理平台配置CNAME记录，指向你的云服务器IP。

  8. 测试：

    在浏览器中输入你的域名，测试前后端分离应用是否能正常访问。

注意：

  • 确保服务器的安全组或防火墙规则正确设置，只对必要的端口开放。
  • 为了安全起见，不要直接使用root用户SSH登录服务器，创建一个新用户并使用SSH密钥认证。
  • 在部署时，确保后端应用配置了正确的数据库连接字符串和其他外部服务的访问参数。
  • 如果使用了数据库，确保数据库服务在云服务器上运行，并且从应用服务器可访问。
  • 在部署前确保已经处理好前端代码中的环境变量，比如API端点，以匹配云服务器的实际IP或域名。
- 阅读更多 -
Copyright © 2025 Tech Blog
All Right Reserved | 京ICP备19053165号