SpringData JPA - ORM 框架下，打造高效数据访问层

目录

一、SpringData JPA 概述

1.1、什么是 JPA 

1.2、什么是 ORM

1.3、什么是 Hibernate

1.4、JPA 和 Hibernate 的关系

1.5、JPA 的优势

二、SpringData JPA 实战开发

2.1、依赖

2.2、配置文件

2.3、启动类

2.4、创建实体

2.5、基于 JpaRepository 的 CRUD

三、SpringDataJPA 多种查询方式

3.1、JpaRepository 查询

3.2、方法命名规则查询

3.3、JPQL 查询

3.4、SQL 查询

3.5、JpaSpecificationExecutor 动态查询

一、SpringData JPA 概述

1.1、什么是 JPA 

全英文名叫 Java Persistence API，就是 java 持久化 api ，是SUN公司推出的一套基于 ORM 的规范。

1.2、什么是 ORM

ORM（Object Relational Mapping）表示对象关系映射. 简单来讲，通过 ORM，就可以把对象映射到关系型数据库中（为了不用 JDBC 那套方法来操作数据库）.

1.3、什么是 Hibernate

Hibernate 是一个对象关系映射框架，对 JDBC 进行了非常轻量级的封装，将 对象 与 数据库 简历映射关系，一个全自动的 ORM 框架.  Hibernate 可以自动生成 SQL 语句，自动执行，使得 Java 程序员可以通过面向对象的思想来操纵数据库.

1.4、JPA 和 Hibernate 的关系

JPA 和 Hibernate 的关系就像 JDBC 和 JDBC驱动 的关系，JPA 是规范，Hibernate 除了作为 ORM 框架之外，也是一种 JPA 实现.

简单来讲，如果使用 JPA 规范数据库操作，底层需要 Hibernate 作为其实现完成持久化.

1.5、JPA 的优势

a）标准化：

JPA 是 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都需要遵循同样的框架，提供相同的 API，大大提高了可移植性性.

b）特性支持：

JPA 框架支持大数据集、事务、并发等容器级事务，在大型企业中发挥极大作用.

c）使用方便：

JPA 的主要目标之一就是提供更加简单的编程模型：在 JPA 框架下创建实体和创建 Java 类一样简单，没有任何限制和约束，只需要使用 javax.persistence.Entity 注解.  另外还提供很多基础 CRUD，避免重复造轮子

d）高级特性：

JPA 中支持面向对象的高级特性，例如 类之间的继承、多态...  使得开发者最大限度的使用面向对象的模型设计企业应用.

二、SpringData JPA 实战开发

2.1、依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

2.2、配置文件

server:
  port: 9000

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/jpa?characterEncoding=utf8&useSSL=false
    username: root
    password: DJSAKOFH0*)(shdf*s*&_(fsbpf*&s)_fg*@_&fg@{!p_#*t_@!bfugiwofhg
    driver-class-name: com.mysql.jdbc.Driver
  jpa:
    database: mysql
    show-sql: true # 显示 sql 语句（项目上线后记得关闭）
    hibernate:
      ddl-auto: update
    open-in-view: false # 一般来讲，建议关闭

ddl-auto 熟悉用于设置自动表，可以实现自动在数据库中为我们创建一个表，表的结构会根据我们定义的实体类决定，具体有 4 种值：

  • create：启动时删除数据库中表，然后创建，退出时不删除数据表.
  • create-drop：启动时删除数据库中表，然后创建，退出时删除数据表，并且如果不存在就报错.
  • update：如果启动时表格式不一致则更新表，原有数据保留
  • validate：项目启动时，表结构进行校验，不一致则报错.
  • none：不采取任何措施.

Ps：表可以是自动创建的，但是数据库必须我们手动创建.

2.3、启动类

@EnableJpaAuditing //用来开启 JPA 审计功能
@SpringBootApplication
class JpaApplication

fun main(args: Array<String>) {
    runApplication<JpaApplication>(*args)
}

 @EnableJpaAuditing： 用来开启 JPA 审计功能，比如在建表中经常会加入 版本号、创建时间、修改时间、创建者、修改者 这五个字段.  为了简化开发，可以将其交给 JPA 来自动填充.

2.4、创建实体

import com.fasterxml.jackson.annotation.JsonFormat
import org.springframework.data.annotation.CreatedBy
import org.springframework.data.annotation.CreatedDate
import org.springframework.data.annotation.LastModifiedBy
import org.springframework.data.annotation.LastModifiedDate
import org.springframework.data.jpa.domain.support.AuditingEntityListener
import java.util.*
import javax.persistence.Column
import javax.persistence.Entity
import javax.persistence.EntityListeners
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id
import javax.persistence.Table
import javax.persistence.Version

@Entity
@Table(name = "user_info")
@EntityListeners(AuditingEntityListener::class)
data class Userinfo(

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null,

    val username: String,

    val age: Int,

    //注意，关于审计信息，都需要使用 var 类型

    @Version
    var version: Long? = null,

    @CreatedBy
    @Column(name = "c_by")
    var cBy: String? = null,

    @LastModifiedBy
    @Column(name = "u_by")
    var uBy: String? = null,

    @CreatedDate
    @field:JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @Column(name = "c_time")
    var cTime: Date? = null,

    @LastModifiedDate
    @field:JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @Column(name = "u_time")
    var uTime: Date? = null,

)
注解作用常用属性
@Data给实体类加get/set/toString/EqualsAndHashCode方法，是lombok的注解
@Entity指定当前类是实体类
@Table指定实体类和表之间的对应关系name：指定数据库表的名称
@EntityListeners在实体类增删改的时候监听，为创建人/创建时间等基础字段赋值value：指定监听类
@Id指定当前字段是主键
@SequenceGenerator指定数据库序列别名sequenceName：数据库序列名
name：取的别名
@GeneratedValue指定主键的生成方式strategy ：指定主键生成策略（一般设置 为GenerationType.IDENTITY，表示自增长）
generator：选择主键别名
@Column指定实体类属性和数据库表之间的对应关系（如果成员变量名和表字段名对应一致，可以省略）name：指定数据库表的列名称。
unique：是否唯一
nullable：是否可以为空
nserttable：是否可以插入
updateable：是否可以更新
columnDefinition: 定义建表时创建此列的DDL
@CreatedBy自动插入创建人
@CreatedDate自动插入创建时间
@LastModifiedBy自动修改更新人
@LastModifiedDate自动修改更细时间
@Version自动更新版本号
@JsonFormat插入/修改/读取的时间转换成想要的格式pattern：展示格式
timezone：国际时间

解释： 

a）主键策略： 

  • SEQUENCE 策略适合拥有序列的数据库，比如 Oracle；
  • IDENTITY 策略适合拥有主键自增长的数据库，比如 MySQL；
  • TABLE 策略是通过一张序列表来维护主键插入的值的，所以适合所有数据库；
  • AUTO 策略是 JPA 自行判断使用上面三个中的哪一个作为主键生成策略；

开发人员应该自行判断使用的是何种数据库，而不是由 JPA 进行判断。

b）审计功能

  • @Version：版本号；进行 update 操作时启动乐观锁，@Version 修饰的字段值与数据库中字段值一致才能进行修改
  • @CreatedDate ：创建时间；进行 insert 操作时，将当前时间插入到 @CreatedDate 修饰字段中；进行 update 操作时，会随实体类中的 @CreatedDate 修饰的字段值进行修改
  • @CreatedBy：创建人；进行 insert 操作时，将当前用户名插入到 @CreatedBy 修饰字段中；进行update操作时，会随实体类中的 @CreatedBy 修饰的字段值进行修改
  • @LastModifiedDate：最后一次修改时间；进行 update 操作时，将当前时间修改进@LastModifiedDate 修饰字段中；进行 insert 操作时，将当前时间插入到 @LastModifiedDate 修饰字段中
  • @LastModifiedBy ：最后一次修改的修改人；进行 update 操作时，将当前修改人修改进@LastModifiedBy 修饰的字段中；进行 insert 操作时，将当前用户名插入到@LastModifiedBy修饰字段中

c）启动审计条件：

  • 启动类上有 @EnableJpaAuditing 注解.
  • 实体类上方加上监听注解 @EntityListeners(AuditingEntityListener::class)

完成上述两个注解后，@CreatedDate、@LastModifiedBy、@Version 就生效了，但是创建人、修改人不会生效，需要我们创建一个配置类，实现 AuditorAware<String> 接口，如下：

@Configuration
class UserAuditor: AuditorAware<String> {

    /**
     * @return 获取当前创建或修改的用户
     */
    override fun getCurrentAuditor(): Optional<String> {
        return Optional.of("我是审计者 cyk")   
    }

}

Ps：正式项目中一般会从 JWT 或者 Session 中获取当前操作该表的用户是谁.

2.5、基于 JpaRepository 的 CRUD

Spring Data JPA 操作数据库，只需要自定有接口，并继承 JpaRepository 接口，无需再接口中定义任何方法，也不需要为接口提供实现类，就能完成基本 CRUD.

a）接口：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository

@Repository
interface UserRepoJpa: JpaRepository<Userinfo, Long>

b）测试类：

import org.cyk.jpa.model.Userinfo
import org.cyk.jpa.repo.UserRepoJpa
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import javax.annotation.Resource

@SpringBootTest
class JpaApplicationTests {

    @Resource
    private lateinit var userRepoJpa: UserRepoJpa

    @Test
    fun test() {
        val obj = Userinfo(
            username = "cyk3",
            age = 21,
        )
        userRepoJpa.save(obj)
        val result = userRepoJpa.findAll()
        result.forEach(::println)
    }

}

执行结果：

Ps：创建人和更新人埋坑，最后会补充~ 

c）SpringDataJPA 的接口继承关系：

Repository  (标记接口、做标记、Repository接口的子接口的实现类对象可以自动被SpringIOC容器所识别，此接口的子接口中可以定义一些指定规范的方法)
    ||
CrudRepository  (定义了一些基本的CRUD方法)
    ||
PagingAndSortingRepository  (定义了排序和分页相关的查询方法)
    ||
JpaRepository    (重写了一些基本测CRUD方法)
    ||
ArticleDao    (自己定义的接口)

三、SpringDataJPA 多种查询方式

3.1、JpaRepository 查询

a）只需要创建一个接口，让他继承 JpaRepository<T, ID> 接口即可

  • T：实体类
  • ID：id 类型
import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository

@Repository
interface UserRepoJpa: JpaRepository<Userinfo, Long>

 此时，你就可以直接使用 JpaRepository<T, ID> 接口 提供的方法：

b）测试：

import org.cyk.jpa.model.Userinfo
import org.cyk.jpa.repo.UserRepoJpa
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import javax.annotation.Resource

@SpringBootTest
class JpaApplicationTests {

    @Resource
    private lateinit var userRepoJpa: UserRepoJpa

    @Test
    fun test() {
        val obj = Userinfo(
            username = "cyk3",
            age = 21,
        )
        userRepoJpa.save(obj)
        val result = userRepoJpa.findAll()
        result.forEach(::println)
    }

}

3.2、方法命名规则查询

a）创建一个接口，继承 JpaRepository 接口，此时你就可以自定义一些方法（方法名有要求），SpringDataJPA 就会再程序执行的时候根据方法名进行解析，自动生成对应的查询语句.

b）规范：

  1. 查询起始词：查询方法通常以 find、read、get、query、count、exists 等词开头。

  2. 属性引用：在起始词之后，你可以引用实体类的属性名（首字母大写）。例如，如果有一个名为 firstName 的属性，你可以通过 findByFirstName 来查询它。

  3. 条件组合：对于多个条件，你可以使用 And 或 Or 连接。例如，findByFirstNameAndLastName 会查找同时匹配 firstName 和 lastName 的记录。

  4. 排序：你可以使用 OrderBy 关键字并指定属性名和排序方向（如 Asc 或 Desc）来排序结果。

  5. 限制结果：使用 First、Top 或 Limit 可以限制返回的记录数。例如，findFirstByName 会返回按 name 排序后的第一个结果。

  6. 聚合函数：Spring Data JPA 也支持聚合函数，如 countBy、sumBy、avgBy 等。

  7. 处理特殊情况：如果属性名包含特殊字符或与 SQL 关键字冲突，可以使用 @Column 注解来明确指定字段名。对于复杂的查询，可以使用 @Query 注解来编写自定义的 SQL 或 JPQL 查询。

  8. 命名规范：属性名在方法名中通常是大写的，以符合 Java 的命名规范，即使它们在数据库或实体类中是小写的。

  9. 分页：如果需要分页查询，可以在方法参数中添加 Pageable 类型的参数。

  10. 流和迭代：除了返回列表或单个实体，方法还可以返回流（Stream）或迭代器（Iterable），以支持更高效的内存使用。

例如：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository

@Repository
interface UserRepoName: JpaRepository<Userinfo, Long> {

    //直接查询
    fun findByUsername(username: String): List<Userinfo>

    //模糊查询
    fun findByUsernameLike(username: String): List<Userinfo>

    //and 查询
    fun findByUsernameAndAge(username: String, age: Int): List<Userinfo>

    //小于等于查询
    fun findByIdLessThanEqual(id: Long): List<Userinfo>

    //between 查询
    fun findByIdBetween(start: Long, end: Long): List<Userinfo>

    //in 查询
    fun findByIdIn(ids: List<Long>): List<Userinfo>

}

测试：

import org.cyk.jpa.repo.UserRepoName
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import javax.annotation.Resource

@SpringBootTest
class JpaNameApplicationTests {

    @Resource
    private lateinit var userRepoName: UserRepoName

    @Test
    fun test1() {
        userRepoName.findByUsername("cyk").forEach(::println)
    }

    @Test
    fun test2() {
        userRepoName.findByUsernameLike("%y%").forEach(::println)
    }

    @Test
    fun test3() {
        userRepoName.findByUsernameAndAge("cyk", 21).forEach(::println)
    }

    @Test
    fun test4() {
        userRepoName.findByIdLessThanEqual(2).forEach(::println)
    }

    @Test
    fun test5() {
        userRepoName.findByIdBetween(1, 3).forEach(::println)
    }

    @Test
    fun test6() {
        userRepoName.findByIdIn(listOf(1,2)).forEach(::println)
    }

}

3.3、JPQL 查询

JPQL，全称是 Java 持久化查询语言，是 JPA 中定义的一种查询语言. 此种语言的用意是让开发者忽略数据库表和表中的字段，而关注实体类及实体类中的属性。

写法十分类似于SQL语句的写法，但是要把查询的表名换成实体类的名称，把表中的字段名换成实体类的属性名称。

接口：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.domain.Pageable
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.query.Param
import org.springframework.stereotype.Repository

@Repository
interface UserRepoJpql: JpaRepository<Userinfo, Long> {

    //占位符从 1 开始
    @Query("from Userinfo where username = ?1 and age <= ?2")
    fun findByCond1(username: String, age: Int): List<Userinfo>

    //参数名 ":" 绑定
    @Query("from Userinfo where username = :username and age <= :age")
    fun findByCond2(@Param("username") username: String,
                    @Param("age") age: Int): List<Userinfo>

    //模糊查询 + 排序
    @Query("from Userinfo where username like %:username% order by cTime desc")
    fun findByCond3(@Param("username") username: String): List<Userinfo>

    //模糊查询 + 分页
    @Query("from Userinfo where username like %:username%")
    fun findByCond4(pageable: Pageable, @Param("username") username: String): List<Userinfo>

    //in 查询
    @Query("from Userinfo where age in :ages")
    fun findByCond5(@Param("ages") ages: List<Int>): List<Userinfo>

    //通过对象进行查询(SPEL 表达式查询)
    @Query("from Userinfo where username = :#{#userinfo.username} and age <= :#{#userinfo.age}")
    fun findByCond6(@Param("userinfo") userinfo: Userinfo): List<Userinfo>

}

测试：

import org.cyk.jpa.model.Userinfo
import org.cyk.jpa.repo.UserRepoJpql
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.data.domain.PageRequest
import javax.annotation.Resource

@SpringBootTest
class JpaJpqlApplicationTests {

    @Resource
    private lateinit var userRepoJpql: UserRepoJpql

    @Test
    fun test1() {
        userRepoJpql.findByCond1("cyk", 21).forEach(::println)
    }

    @Test
    fun test2() {
        userRepoJpql.findByCond2("cyk", 21).forEach(::println)
    }

    @Test
    fun test3() {
        userRepoJpql.findByCond3("y").forEach(::println)
    }

    @Test
    fun test4() {
        val pg = PageRequest.of(1, 2)
        userRepoJpql.findByCond4(pg, "y").forEach(::println)
    }

    @Test
    fun test5() {
        userRepoJpql.findByCond5(listOf(21,22,23)).forEach(::println)
    }

    @Test
    fun test6() {
        userRepoJpql.findByCond6(
            Userinfo(
                username = "cyk",
                age = 21
            )
        ).forEach(::println)
    }

}

3.4、SQL 查询

在 @Query 注解中，设置属性 nativeQuery = true，表示使用 SQL 语句进行查询.

基本不会使用这种情况，除非是非常复杂的业务情况.

接口：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Query

interface UserRepoSql: JpaRepository<Userinfo, Long> {

    @Query(value = "select * from user_info where username = ?1 and age = ?2", nativeQuery = true)
    fun findByCond(username: String, age: Int): List<Userinfo>

}

测试：

import org.cyk.jpa.repo.UserRepoSql
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import javax.annotation.Resource

@SpringBootTest
class JpaSqlApplicationTests {

    @Resource
    private lateinit var userRepoSql: UserRepoSql

    @Test
    fun test() {
        userRepoSql.findByCond("cyk", 21).forEach(::println)
    }

}

3.5、JpaSpecificationExecutor 动态查询

类似我们写动态 SQL，给定的条件不是固定的，需要动态的构建查询语句.

SpringDataJPA 中，我们只需要自定义个接口，继承 JpaRepository 和 JpaSpecificationExecutor 接口即可.

接口：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.JpaSpecificationExecutor
import org.springframework.stereotype.Repository

@Repository
interface UserRepoJpaSpe: JpaRepository<Userinfo, Long>, JpaSpecificationExecutor<Userinfo>

测试：

import org.cyk.jpa.model.Userinfo
import org.cyk.jpa.repo.UserRepoJpaSpe
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.data.domain.PageRequest
import org.springframework.data.domain.Sort
import org.springframework.data.jpa.domain.Specification
import javax.annotation.Resource
import javax.persistence.criteria.Predicate

@SpringBootTest
class JpaSpeApplicationTests {

    @Resource
    private lateinit var userRepoJpaSpe: UserRepoJpaSpe

    //username 和 age 不为空才作为查询条件
    @Test
    fun test1() {
        //模拟外部输入
        val username: String? = ""
        val age: Int? = 21

        /**
         * 拼接查询条件
         * root: 代表实体对象，可以通过它获取属性值
         * cq: 用于生成SQL语句
         * cb: 用于拼接查询条件
         */
        val s = Specification<Userinfo> { root, cq, cb ->
            val predicates = mutableListOf<Predicate>()

            if (!username.isNullOrBlank()) {
                val p = cb.equal(root.get<String>("username"), username)
                predicates.add(p)
            }

            age?.let {
                val p = cb.equal(root.get<Int>("age"), it)
                predicates.add(p)
            }

            cb.and(*predicates.toTypedArray())
        }

        //查询
        userRepoJpaSpe.findAll(s).forEach(::println)
    }

    //查询 + 分页 + 排序（倒序）
    @Test
    fun test2() {
        //模拟外部输入
        val username: String? = ""
        val age: Int? = 21

        /**
         * 拼接查询条件
         * root: 代表实体对象，可以通过它获取属性值
         * cq: 用于生成SQL语句
         * cb: 用于拼接查询条件
         */
        val s = Specification<Userinfo> { root, cq, cb ->
            val predicates = mutableListOf<Predicate>()

            if (!username.isNullOrBlank()) {
                val p = cb.equal(root.get<String>("username"), username)
                predicates.add(p)
            }

            age?.let {
                val p = cb.equal(root.get<Int>("age"), it)
                predicates.add(p)
            }

            cb.and(*predicates.toTypedArray())
        }

        //分页 + 排序
        val pg = PageRequest.of(0, 3, Sort.by(Sort.Order.desc("cTime"))) //注意这里对应的是成员变量名(而非表中的字段名)

        val result = userRepoJpaSpe.findAll(s, pg)
        result.forEach(::println)
    }

}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/593828.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

超市购物|基于SprinBoot+vue的超市购物系统(源码+数据库+文档)

超市购物|基于SprinBoot+vue的超市购物系统(源码+数据库+文档)

目录 基于SprinBootvue的企业人事管理系统 一、前言 二、系统设计 三、系统功能设计 1商品管理 2公告管理 3公告类型管理 四、数据库设计 五、核心代码 六、论文参考 七、最新计算机毕设选题推荐 八、源码获取&#xff1a; 博主介绍&#xff1a;✌️大厂码农|毕设…
阅读更多...
C语言--带环链表问题

C语言--带环链表问题

继续学习 一、判断链表是否带环 141. 环形链表 - 力扣&#xff08;LeetCode&#xff09; 思路&#xff1a;用快慢指针&#xff0c;快指针走两步&#xff0c;慢指针走一步&#xff0c;当慢指针走一半快指针进到环里 当慢指针进环&#xff0c;快指针已经在环中转了一会儿了 | |…
阅读更多...
“字节跳动-文远知行杯”——广东工业大学第十四届程序设计竞赛

“字节跳动-文远知行杯”——广东工业大学第十四届程序设计竞赛

补题补题&#xff1a; A、hzy 和zsl 的生存挑战 题解&#xff1a;由于我们去考虑最优解&#xff0c;那么其中两人就应该是这样走法&#xff0c;一人选择相同数&#xff0c;另一人选择相反数&#xff0c;这样必会通关 #include <iostream> using namespace std;int main(…
阅读更多...
Web服务器手动配置

Web服务器手动配置

目录 配置环境 http配置 配置步骤 1、首先安装Nginx&#xff08;已经安装的跳过这步&#xff09; 2、查看一下下Nginx的配置文件结构&#xff0c;了解如何配置&#xff0c;以及配置的各个条目有什么作用&#xff08;为接下来的配置打基础&#xff09; 3、创建你的网页 4、…
阅读更多...
【银角大王——Django课程——靓号搜索实现/单独一篇】

【银角大王——Django课程——靓号搜索实现/单独一篇】

搜索框功能实现 靓号搜索在Django框架中搜索功能实现——底层就是模糊查询添加一个搜索框&#xff0c;使用bootstrap框架将GO&#xff01;修改成一个放大镜靓号列表函数代码解释效果演示 靓号搜索 在Django框架中搜索功能实现——底层就是模糊查询 数字条件用法字符串条件用法…
阅读更多...
学习如何使用PyQt5实现notebook功能

学习如何使用PyQt5实现notebook功能

百度搜索“pyqt5中notebook控件”&#xff0c;AI自动生成相应例子的代码。在 PyQt5 中&#xff0c;QTabWidget 类被用作 Notebook 控件。以下是一个简单的示例&#xff0c;展示如何创建一个带有两个标签的 Notebook 控件&#xff0c;并在每个标签中放置一些文本。 import sys f…
阅读更多...
电子信息工程专业就业前景怎么样

电子信息工程专业就业前景怎么样

电子信息工程专业的就业前景十分广阔&#xff0c;主要得益于现代社会对信息技术的依赖不断加深以及科技的快速发展&#xff0c;以下是上大学网&#xff08;www.sdaxue.com&#xff09;对该专业就业前景的具体分析&#xff0c;供大家参考&#xff01; 行业需求广泛&#xff1a;随…
阅读更多...
VBA字典与数组第十四讲：单列数组与单行数组间的运算

VBA字典与数组第十四讲：单列数组与单行数组间的运算

《VBA数组与字典方案》教程&#xff08;10144533&#xff09;是我推出的第三套教程&#xff0c;目前已经是第二版修订了。这套教程定位于中级&#xff0c;字典是VBA的精华&#xff0c;我要求学员必学。7.1.3.9教程和手册掌握后&#xff0c;可以解决大多数工作中遇到的实际问题。…
阅读更多...
动态规划 ------ 背包问题

动态规划 ------ 背包问题

文章目录 1. 01 背包问题1.二维解决2. 一维优化 2. 完全背包问题1.暴力3 for.2. 二维优化3. 一维优化 3. 多重背包问题Ⅰ.1. 二维解决2. 一维优化 4. 多重背包问题Ⅱ5. 混合背包问题6. 二维费用背包问题7. 分组背包问题 背包问题是动态规划中非常典型的一些题&#xff0c;本篇文…
阅读更多...
ctfshow——SSRF

ctfshow——SSRF

文章目录 web 351web 352web 353web 354web 355web 356web357web 358web 359web 360 SSRF(Server-Side Request Forgery&#xff1a;服务器端请求伪造) 是一种由攻击者构造形成由服务端发起请求的一个安全漏洞。一般情况下&#xff0c;SSRF攻击的目标是从外网无法访问的内部系统…
阅读更多...
同向双指针（滑动窗口）算法

同向双指针（滑动窗口）算法

209. 长度最小的子数组 这里的更新结果就题来定 class Solution {public int minSubArrayLen(int target, int[] nums) {int sum 0;int len 0;int f 0;for(int left 0, right 0; right < nums.length;){//求和sum nums[right];while(sum > target){//lenint t ri…
阅读更多...
分布式锁之-redis

分布式锁之-redis

什么是分布式锁&#xff1f; 即分布式系统中的锁。在单体应用中我们通过锁解决的是控制共享资源访问的问题&#xff0c;而分布式锁&#xff0c;就是解决了分布式系统中控制共享资源访问的问题。与单体应用不同的是&#xff0c;分布式系统中竞争共享资源的最小粒度从线程升级成了…
阅读更多...
JVM垃圾回收器G1大总结-详解

JVM垃圾回收器G1大总结-详解

一、介绍: 1.停顿时间模型?? 作为CMS收集器的替代者和继承人&#xff0c;G1是基于“停顿时间模型”诞生的的垃圾收集器&#xff0c;停顿时间模型的意思是能够支持指定在一个长度为M毫秒的时间片段内&#xff0c;消耗在垃圾收集上的时间大概率不超过N毫秒这样的目标. 2.G1摒…
阅读更多...
进程与线程（进程）

进程与线程（进程）

进程&#xff1a; 概念&#xff1a;进程是进程实体的运行过程&#xff0c;是系统进行资源分配和调度的一个独立单位 PID:当进程被创建时&#xff0c;操作系统会为该进程分配一个唯一的、不重复的“身份证号” 组成&#xff1a; PCB&#xff08;进程控制块&#xff09;&#…
阅读更多...
使用AIGC生成软件类图表

使用AIGC生成软件类图表

文章目录 如何使用 AI 生成软件类图表什么是 MermaidMermaid 的图片如何保存&#xff1f;mermaid.liveDraw.io Mermaid可以画什么图&#xff1f;流程图时序图 / 序列图类图状态图甘特图实体关系图 / ER图 如何使用 AI 生成软件类图表 ChatGPT 大语言模型不能直接生成各类图表。…
阅读更多...
W801学习笔记二十：宋词学习应用

W801学习笔记二十：宋词学习应用

前三章完成了唐诗的应用&#xff0c;本章将实现宋词的学习应用。 宋词与唐诗的区别不大&#xff0c;马上开始。 1、我们需要参考前面唐诗的方式&#xff0c;把宋词文本下载下来&#xff0c;并进行格式整理。 W801学习笔记十七&#xff1a;古诗学习应用——上 2、在菜单中添加…
阅读更多...
电脑上的视频在电视上播放

电脑上的视频在电视上播放

视频右键->播放到设备->客厅电视 海信电视测试成功
阅读更多...
BI不等同数据分析，别搞错了！

BI不等同数据分析，别搞错了！

✅作者简介&#xff1a;《数据运营&#xff1a;数据分析模型撬动新零售实战》作者、《数据实践之美》作者、数据科技公司创始人、多次参加国家级大数据行业标准研讨及制定、高端企培合作讲师。 &#x1f338;公众号&#xff1a;风姑娘的数字视角&#xff0c;免费分享数据应用相…
阅读更多...
【Transformer系列（1）】self-attention自注意力

【Transformer系列（1）】self-attention自注意力

一、self-attention流程 自注意力机制和注意力机制的区别在于&#xff0c;注意力机制中的Q&#xff08;查询向量&#xff09;&#xff0c;K&#xff08;键向量&#xff09;&#xff0c;V&#xff08;值向量&#xff09;是同源的&#xff0c;而一般的注意力机制&#xff0c;Q和…
阅读更多...
谈谈Tcpserver开启多线程并发处理遇到的问题！

谈谈Tcpserver开启多线程并发处理遇到的问题！

最近在学习最基础的socket网络编程&#xff0c;在Tcpserver开启多线程并发处理时遇到了一些问题&#xff01; 说明 在linux以及Windows的共享文件夹进行编写的&#xff0c;所以代码中有的部分使用 #ifdef WIN64 ... #else ... #endif 进入正题&#xff01;&#xff01;&…
阅读更多...
最新文章

Copyright @ 2022~2023