【精选必读】MyBatis关联查询及注解开发

news2024/11/26 17:33:07

文章目录

    • MyBatis关联查询
      • MyBatis一对一关联查询
        • 创建持久层接口
        • 创建映射文件
        • 配置文件注册映射文件
        • 测试一对一关联查询
      • MyBatis一对多关联查询
        • 创建持久层接口
        • 创建映射文件
        • 测试一对多关联查询
      • MyBatis多对多关联查询
        • 创建持久层接口
        • 创建映射文件
        • 测试多对多关联查询
      • MyBatis分解式查询_一对多
        • 创建每个查询语句的持久层方法
        • 在映射文件中进行配置
        • 修改主表映射文件中的查询方法
        • 测试查询方法
      • MyBatis分解式查询_一对一
        • 创建每个查询语句的持久层方法
        • 在映射文件中进行配置
        • 修改主表映射文件中的查询方法
        • 测试查询方法
      • MyBatis延迟加载
        • 开启延迟加载
        • 测试延迟加载
    • MyBatis注解开发
      • 环境搭建
      • 增删改查
      • 动态Sql
        • 使用脚本标签
        • 在方法中构建动态Sql
      • 自定义映射关系
      • 二级缓存
      • 一对一关联查询
      • 一对多关联查询
      • 注解开发与映射文件开发的对比

在这里插入图片描述

MyBatis关联查询

MyBatis的关联查询分为一对一关联查询和一对多关联查询。

  • 查询对象时，将关联的另一个对象查询出来，就是一对一关联查询。
  • 查询对象时，将关联的另一个对象的集合查询出来，就是一对多关联查询。

例如有学生类和班级类：

一个学生对应一个班级，也就是学生类中有一个班级属性，这就是一对一关系。

一个班级对应多个学生，也就是班级类中有一个学生集合属性，这就是一对多关系。

实体类设计如下：

public class Student {
  private int sid;
  private String name;
  private int age;
  private String sex;
  private Classes classes;
  // 省略getter/setter/toString
}


public class Classes {
  private int cid;
  private String className;
  private List<Student> studentList;
  // 省略getter/setter/toString
}

数据库设计如下：

MyBatis一对一关联查询

查询学生时，将关联的一个班级对象查询出来，就是一对一关联查询。

创建持久层接口
public interface StudentMapper {
  List<Student> findAll();
}
创建映射文件
<resultMap id="studentMapper" type="com.mybatis.pojo.Student">
  <!-- 主键列 -->
  <id property="sid" column="sid"></id>
  <!-- 普通列 -->
  <result property="name" column="name"></result>
  <result property="age" column="age"></result>
  <result property="sex" column="sex"></result>
  <!-- 一对一对象列 property:属性名  column:关联列名 javaType：对象类型-->
  <association property="classes" column="classId" javaType="com.mybatis.pojo.Classes">
    <!-- 关联对象主键列 -->
    <id property="cid" column="cid"></id>
    <!-- 关联对象普通列 -->
    <result property="className" column="className"></result>
  </association>
</resultMap>

<!-- 多表查询，级联查询学生和其班级 -->
<select id="findAll" resultMap="studentMapper">
   select * from student left join classes on student.classId = classes.cid;
</select>
配置文件注册映射文件
<mappers>
  <package name="com.mybatis.mapper"/>
</mappers>
测试一对一关联查询
InputStream is = null;
SqlSession session = null;


@Before
public void before() throws IOException {
  is = Resources.getResourceAsStream("SqlMapConfig.xml");
  SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  SqlSessionFactory factory = builder.build(is);
  session = factory.openSession();
}


@After
public void after() throws IOException {
  session.close();
  is.close();
}


@Test
public void testFindAllStudent(){
  StudentMapper studentMapper = session.getMapper(StudentMapper.class);
  List<Student> all = studentMapper.findAll();
  all.forEach(System.out::println);
}

MyBatis一对多关联查询

查询班级时，将关联的学生集合查询出来，就是一对多关联查询。

创建持久层接口
public interface ClassesMapper {
  List<Classes> findAll();
}
创建映射文件
<resultMap id="classesMapper" type="com.mybatis.pojo.Classes">
  <id property="cid" column="cid"></id>
  <result property="className" column="className"></result>
  <!-- 集合列  property：属性名  column：关联列名 ofType：集合的泛型 -->
  <collection property="studentList" column="classId" ofType="com.mybatis.pojo.Student">
    <id property="sid" column="sid"></id>
    <result property="name" column="name"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
  </collection>
</resultMap>


<!-- 多表查询，级联查询班级和它的学生 -->
<select id="findAll" resultMap="classesMapper">
   select * from classes left join student  on classes.cid = student.classId;
</select>
测试一对多关联查询
@Test
public void testFindAllClasses() {
  ClassesMapper classesMapper = session.getMapper(ClassesMapper.class);
  List<Classes> all = classesMapper.findAll();
  all.forEach(System.out::println);
}

MyBatis多对多关联查询

MyBatis多对多关联查询本质就是两个一对多关联查询。

例如有老师类和班级类：

一个老师对应多个班级，也就是老师类中有一个班级集合属性。

一个班级对应多个老师，也就是班级类中有一个老师集合属性。

实体类设计如下：

public class Teacher {
  private Integer tid;
  private String tname;
  private List<Classes> classes;
  // 省略getter/setter/toString
}


public class Classes {
  private Integer cid;
  private String className;
  private List<Student> studentList;
  private List<Teacher> teacherList;
  // 省略getter/setter/toString
}

在数据库设计中，需要建立中间表，双方与中间表均为一对多关系。

接下来测试查询老师时，将关联的班级集合查询出来。

创建持久层接口
public interface TeacherMapper {
  List<Teacher> findAll();
}
创建映射文件
<resultMap id="teacherMapper" type="com.mybatis.pojo.Teacher">
  <id column="tid" property="tid"></id>
  <result column="tname" property="tname"></result>
  <collection property="classes" column="tid" ofType="com.mybatis.pojo.Classes">
    <id column="cid" property="cid"></id>
    <result column="className" property="className"></result>
  </collection>
</resultMap>


<select id="findAll" resultMap="teacherMapper">
   select *
   from teacher
   left join classes_teacher
   on teacher.tid = classes_teacher.tid
   left join classes
   on classes_teacher.cid = classes.cid
</select>
测试多对多关联查询
@Test
public void testFindAllTeacher() {
  TeacherMapper teacherMapper = session.getMapper(TeacherMapper.class);
  List<Teacher> all = teacherMapper.findAll();
  all.forEach(System.out::println);
}

如果想查询班级时，将关联的老师集合查询出来，只需要修改班级映射文件的Sql语句和<resultMap>即可：

<resultMap id="classesMapper" type="com.mybatis.pojo.Classes">
  <id property="cid" column="cid"></id>
  <result property="className" column="className"></result>
  <!-- 集合列  property：属性名  column：关联列名 ofType：集合的泛型 -->
  <collection property="studentList" column="classId" ofType="com.mybatis.pojo.Student">
    <id property="sid" column="sid"></id>
    <result property="name" column="name"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
  </collection>
  <collection property="teacherList" column="cid" ofType="com.mybatis.pojo.Teacher">
    <id property="tid" column="tid"></id>
    <result property="tname" column="tname"></result>
  </collection>
</resultMap>


<select id="findAll" resultMap="classesMapper">
   select *
   from classes
   left join student
   on classes.cid = student.classId
   left join classes_teacher
   on classes.cid = classes_teacher.cid
   left join teacher
   on classes_teacher.tid = teacher.tid;
</select>

MyBatis分解式查询_一对多

在MyBatis多表查询中，使用连接查询时一个Sql语句就可以查询出所有的数据。如：

# 查询班级时关联查询出学生
select *
  from classes
  left join student
  on student.classId = classes.cid

也可以使用分解式查询，即将一个连接Sql语句分解为多条Sql语句，如：

# 查询班级时关联查询出学生
select * from classes;
select * from student where classId = 1;
select * from student where classId = 2;

这种写法也叫N+1查询。

连接查询：

  • 优点：降低查询次数，从而提高查询效率。
  • 缺点：如果查询返回的结果集较多会消耗内存空间。

N+1查询：

  • 优点：结果集分步获取，节省内存空间。
  • 缺点：由于需要执行多次查询，相比连接查询效率低。

我们以查询班级时关联查询出学生为例，使用N+1查询：

创建每个查询语句的持久层方法
public interface ClassesMapper {
  // 查询所有班级
  List<Classes> findAll();
}


public interface StudentMapper {
  // 根据班级Id查询学生
  List<Student> findByClassId(int classId);
}
在映射文件中进行配置
<select id="findAll" resultType="com.mybatis.pojo.Classes">
   select * from classes
</select>


<select id="findByClassId" resultType="com.mybatis.pojo.Student" parameterType="int">
   select * from student where classId = ${classId}
</select>
修改主表映射文件中的查询方法
<!-- 自定义映射关系  -->
<resultMap id="MyClassesMapper" type="com.mybatis.pojo.Classes">
  <id property="cid" column="cid"></id>
  <result property="className" column="className"></result>
  <!-- select：从表查询调用的方法  column：调用方法时传入的参数字段   -->
  <collection property="studentList"
        ofType="com.mybatis.pojo.Student"        select="com.mybatis.mapper2.StudentMapper2.findByClassId"
        column="cid">
  </collection>
</resultMap>


<select id="findAll" resultMap="MyClassesMapper">
   select * from classes
</select>
测试查询方法
@Test
public void testFindAllClasses2(){
  ClassesMapper2 classesMapper2 = session.getMapper(ClassesMapper2.class);
  List<Classes> all = classesMapper2.findAll();
  all.forEach(System.out::println);
}

我们可以看到在控制台打印出了多条Sql语句

MyBatis分解式查询_一对一

查询学生时关联查询出班级也可以使用分解式查询，首先将查询语句分开：

select * from student;
select * from classes where cid = ?;
创建每个查询语句的持久层方法
public interface StudentMapper {
   // 查询所有学生
  List<Student> findAll();
}


public interface ClassesMapper {
  // 根据ID查询班级
  Classes findByCid(int cid);
}
在映射文件中进行配置
<select id="findAll" resultType="com.mybatis.pojo.Student">
   select *
   from student
</select>


<select id="findByCid" resultType="com.mybatis.pojo.Classes" parameterType="int">
   select * from classes where cid = ${cid}
</select>
修改主表映射文件中的查询方法
<resultMap id="MyStudentMapper" type="com.mybatis.pojo.Student">
  <id property="sid" column="sid"></id>
  <result property="name" column="name"></result>
  <result property="age" column="age"></result>
  <result property="sex" column="sex"></result>
  <association property="classes"
         javaType="com.mybatis.pojo.Classes"
         select="com.mybatis.mapper2.ClassesMapper2.findByCid"
         column="classId">
  </association>
</resultMap>


<select id="findAll" resultMap="MyStudentMapper">
   select *
   from student
</select>
测试查询方法
@Test
public void testFindAllStudent2(){
  StudentMapper2 studentMapper2 = session.getMapper(StudentMapper2.class);
  List<Student> all = studentMapper2.findAll();
  all.forEach(System.out::println);
}

MyBatis延迟加载

分解式查询又分为两种加载方式：

  • 立即加载：在查询主表时就执行所有的Sql语句。
  • 延迟加载：又叫懒加载，首先执行主表的查询语句，使用从表数据时才触发从表的查询语句。

延迟加载在获取关联数据时速度较慢，但可以节约资源，即用即取。

开启延迟加载

  • 设置所有的N+1查询都为延迟加载：

    <settings>
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

  • 设置某个方法为延迟加载：

    在<association>、<collection>中添加fetchType属性设置加载方式。lazy：延迟加载；eager：立即加载。

测试延迟加载
@Test
public void testFindAllClasses2(){
  ClassesMapper2 classesMapper2 = session.getMapper(ClassesMapper2.class);
  List<Classes> all = classesMapper2.findAll();
  all.forEach(System.out::println);
  System.out.println("-------------------------");
  System.out.println(all.get(0).getStudentList());
}

由于打印对象时会调用对象的toString方法，toString方法默认会触发延迟加载的查询，所以我们无法测试出延迟加载的效果。

我们在配置文件设置lazyLoadTriggerMethods属性，该属性指定对象的什么方法触发延迟加载，设置为空字符串即可。

<settings>
  <setting name="lazyLoadTriggerMethods" value=""/>
</settings>

一般情况下，一对多查询使用延迟加载，一对一查询使用立即加载。

MyBatis注解开发

环境搭建

MyBatis可以使用注解替代映射文件。映射文件的作用就是定义Sql语句，可以在持久层接口上使用@Select/@Delete/@Insert/@Update定义Sql语句，这样就不需要使用映射文件了。

  1. 创建maven工程，引入依赖

  2. 创建mybatis核心配置文件SqlMapConfig.xml

  3. 将log4j.properties文件放入resources中，让控制台打印SQL语句。

  4. 创建实体类

  5. 创建持久层接口，并在接口方法上定义Sql语句

    public interface UserMapper {
  @Select("select * from user")
  List<User> findAll();
}

    由于注解在方法上方，而方法中就有参数类型和返回值类型，所以使用注解开发不需要定义参数类型和返回值类型

  6. 在核心配置文件注册持久层接口，由于没有映射文件，所以只能采用注册接口或注册包的方法。

    <mappers>
  <package name="com.mybatis.mapper"/>
</mappers>

  7. 测试方法

    InputStream is = null;
SqlSession session = null;
UserMapper userMapper = null;
@Before
public void before() throws IOException {
  is = Resources.getResourceAsStream("SqlMapConfig.xml");
  SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  SqlSessionFactory factory = builder.build(is);
  session = factory.openSession();
  userMapper = session.getMapper(UserMapper.class);
}

@After
public void after() throws IOException {
  session.close();
  is.close();
}

@Test
public void testFindAll(){
  List<User> all = userMapper.findAll();
  all.forEach(System.out::println);
}

增删改查

接下来写一套基于MyBatis注解的增删改查方法：

@SelectKey(keyColumn = "id", keyProperty = "id", resultType = int.class,before = false, statement = "SELECT LAST_INSERT_ID()")
@Insert("insert into user(username,sex,address) values(#{username},#{sex},#{address})")
void add(User user);


@Update("update user set username = #{username},sex=#{sex},address=#{address} where id = #{id}")
void update(User user);


@Delete("delete from user where id = #{id}")
void delete(int id);


@Select("select * from user where username like #{username}")
List<User> findByUsernameLike(String username);

动态Sql

MyBatis注解开发中有两种方式构建动态Sql：

使用脚本标签

将Sql嵌套在<script>内即可使用动态Sql标签：

// 根据任意条件查询
@Select("<script>" +
    "  select * from user\n" +
    "     <where>\n" +
    "       <if test=\"username != null and username.length() != 0\">\n" +
    "         username like #{username}\n" +
    "       </if>\n" +
    "       <if test=\"sex != null and sex.length() != 0\">\n" +
    "         and sex = #{sex}\n" +
    "       </if>\n" +
    "       <if test=\"address != null and address.length() != 0\">\n" +
    "         and address = #{address}\n" +
    "       </if>\n" +
    "     </where>" +
    "</script>")
List<User> findByCondition(User user);
在方法中构建动态Sql

在MyBatis中有@SelectProvider、@UpdateProvider、@DeleteProvider、@InsertProvider注解。当使用这些注解时将不在注解中直接编写SQL，而是调用某个类的方法来生成SQL。

// 生成根据任意条件查询的Sql语句
public String findByConditionSql(User user){
  StringBuffer sb = new StringBuffer("select * from user where 1=1 ");
  if (user.getUsername() != null && user.getUsername().length() != 0){
    sb.append(" and username like #{username} ");
   }
  if (user.getSex() != null && user.getSex().length() != 0){
    sb.append(" and sex = #{sex} ");
   }
  if (user.getAddress() != null && user.getAddress().length() != 0){
    sb.append(" and address = #{address} ");
   }
  return sb.toString();
}

自定义映射关系

当POJO属性名与数据库列名不一致时，需要自定义实体类和结果集的映射关系，在MyBatis注解开发中，使用@Results定义并使用自定义映射，使用@ResultMap使用自定义映射，用法如下：

// 查询所有用户
@Results(id = "userDiyMapper" ,value = {
  @Result(id = true,property = "id",column = "id"),
  @Result(property = "username",column = "username1"),
  @Result(property = "sex",column = "sex1"),
  @Result(property = "address",column = "address1"),
})
@Select("select * from user")
List<User> findAll();


// 根据id查询
@ResultMap("userDiyMapper")
@Select("select * from user where id = #{id}")
User findById(int id);

二级缓存

MyBatis默认开启一级缓存，接下来我们学习如何在注解开发时使用二级缓存：

  1. POJO类实现Serializable接口。

  2. 在MyBatis配置文件添加如下设置：

    <settings>
  <setting name="cacheEnabled" value="true"/>
</settings>

  3. 在持久层接口上方加注解@CacheNamespace(blocking=true)，该接口的所有方法都支持二级缓存。

  4. 测试二级缓存

    @Test
public void testCache() throws IOException {
  InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
  SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  SqlSessionFactory factory = builder.build(is);
  SqlSession session1 = factory.openSession();
  SqlSession session2 = factory.openSession();


  User user1 = session1.getMapper(UserMapper.class).findById(1);
  System.out.println(user1);
  System.out.println(user1.hashCode());
  session1.commit(); // 清空一次缓存，将数据存到二级缓存
  User user2 = session2.getMapper(UserMapper.class).findById(1);
  System.out.println(user2);
  System.out.println(user2.hashCode());
}

一对一关联查询

在MyBatis的注解开发中对于多表查询只支持分解查询，不支持连接查询。

  1. 创建实体类

    public class Student {
  private int sid;
  private String name;
  private int age;
  private String sex;
  private Classes classes;
  // 省略getter/setter/toString
}


public class Classes {
  private int cid;
  private String className;
  private List<Student> students;
  // 省略getter/setter/toString
}

  2. 创建分解后的查询方法

    public interface StudentMapper {
  @Select("select * from student")
  List<Student> findAll();
}


public interface ClassesMapper {
  // 根据id查询班级
  @Select("select * from classes where cid = #{cid}")
  Classes findByCid(Integer cid);
}

  3. 主表的查询配置自定义映射关系

    @Select("select * from student")
// 自定义映射关系
@Results(id = "studentMapper",value = {
  @Result(id = true,property = "sid",column = "sid"),
  @Result(property = "name",column = "name"),
  @Result(property = "age",column = "age"),
  @Result(property = "sex",column = "sex"),
  /**
       * property:属性名
       * column:调用从表方法时传入的参数列
       * one:表示该属性是一个对象
       * select：调用的从表方法
       * fetchType：加载方式
       */
  @Result(property = "classes",column = "classId",
      one = @One(select = "com.mybatis.mapper.ClassesMapper.findByCid",
            fetchType = FetchType.EAGER))
})
List<Student> findAll();

  4. 测试

    @Test
public void findAllStudent(){
  StudentMapper studentMapper = session.getMapper(StudentMapper.class);
  List<Student> all = studentMapper.findAll();
  all.forEach(System.out::println);
}

一对多关联查询

  1. 创建分解后的查询方法

    public interface ClassesMapper {
  // 查询所有班级
  @Select("select * from classes")
  List<Classes> findAll();
}


public interface StudentMapper {
  // 根据班级id查询学生
  @Select("select * from student where classId = #{classId}")
  List<Student> findByClassId(int classId);
}

  2. 主表的查询配置自定义映射关系

    // 查询所有班级
@Select("select * from classes")
@Results(id = "classMapper", value = {
  @Result(id = true, property = "cid", column = "cid"),
  @Result(property = "className", column = "className"),
  // many：表示该属性是一个集合
  @Result(property = "studentList", column = "cid",
      many = @Many(select = "com.mybatis.mapper.StudentMapper.findByClassId",
             fetchType = FetchType.LAZY))
})
List<Classes> findAll();

  3. 测试

    @Test
public void findAllClasses(){
  ClassesMapper classesMapper = session.getMapper(ClassesMapper.class);
  List<Classes> all = classesMapper.findAll();
  all.forEach(System.out::println);
}

注解开发与映射文件开发的对比

MyBatis中更推荐使用映射文件开发，Spring、SpringBoot更推荐注解方式。具体使用要视项目情况而定。它们的优点对比如下：

映射文件：

  • 代码与Sql语句是解耦的，修改时只需修改配置文件，无需修改源码。
  • Sql语句集中，利于快速了解和维护项目。
  • 级联查询支持连接查询和分解查询两种方式，注解开发只支持分解查询。

注解：

  • 配置简单，开发效率高。
  • 类型安全，在编译期即可进行校验，不用等到运行时才发现错误。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

性能测试必看系列之Jmeter：硬件性能监控指标

性能测试必看系列之Jmeter：硬件性能监控指标

硬件性能监控指标 一、性能监控初步介绍 性能测试的主要目标 1.在当前的服务器配置情况&#xff0c;最大的用户数 2.平均响应时间ART&#xff0c;找出时间较长的业务 3.每秒事务数TPS&#xff0c;服务器的处理能力 性能测试涉及的内容 1.客户端性能测试&#xff1a;web前…
阅读更多...
一. BEV感知算法介绍

一. BEV感知算法介绍

目录 前言1. BEV感知算法的概念2. BEV感知算法数据形式3. BEV开源数据集介绍3.1 KITTI数据集3.2 nuScenes数据集 4. BEV感知方法分类4.1 纯点云方案4.2 纯视觉方案4.3 多模态方案 5. BEV感知算法的优劣6. BEV感知算法的应用介绍7. 课程框架介绍与配置总结下载链接参考 前言 自动…
阅读更多...
Nginx常见的中间件漏洞

Nginx常见的中间件漏洞

目录 1、Nginx文件名逻辑漏洞 2、Nginx解析漏洞 3、Nginx越权读取缓存漏洞 这里需要的漏洞环境可以看&#xff1a;Nginx 配置错误导致的漏洞-CSDN博客 1、Nginx文件名逻辑漏洞 该漏洞利用条件有两个&#xff1a; Nginx 0.8.41 ~ 1.4.3 / 1.5.0 ~ 1.5.7 php-fpm.conf中的s…
阅读更多...
由于找不到vcruntime140.dll无法继续执行代码-提供5个修复方法分你对比

由于找不到vcruntime140.dll无法继续执行代码-提供5个修复方法分你对比

摘要&#xff1a;本文将介绍vcruntime140.dll文件的作用及其在程序运行中的重要性&#xff0c;并提供五个解决vcruntime140.dll无法继续执行的方法。 一、vcruntime140.dll文件介绍 vcruntime140.dll是Windows操作系统中的一项重要文件&#xff0c;它是由Microsoft Visual C提…
阅读更多...
交换技术-电路交换-报文交换-分组交换

交换技术-电路交换-报文交换-分组交换

交换技术是指主机之间、通信设备之间或主机与通信设备之间为交换信息所采用的数据格式和交换装置的方式。按交换技术可分为&#xff1a;电路交换、报文交换和分组交换。 电路交换 交换(switching)&#xff0c;就是按照某种方式动态地分配传输线路的资源。 电路交换是在源结点…
阅读更多...
Scrapy爬虫异步框架之持久化存储（一篇文章齐全）

Scrapy爬虫异步框架之持久化存储（一篇文章齐全）

1、Scrapy框架初识&#xff08;点击前往查阅&#xff09; 2、Scrapy框架持久化存储&#xff08;点击前往查阅&#xff09; 3、Scrapy框架内置管道&#xff08;点击前往查阅&#xff09; 4、Scrapy框架中间件&#xff08;点击前往查阅&#xff09; Scrapy 是一个开源的、基于…
阅读更多...
如何在Ubuntu系统上安装MongoDB

如何在Ubuntu系统上安装MongoDB

简单介绍 MongoDB是由C语言编写的&#xff0c;是一个基于分布式文件存储的开源数据库系统。在高负载的情况下&#xff0c;添加更多的节点&#xff0c;可以保证服务器性能。MongoDB旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB将数据存储为一个文档&#xff0c;数…
阅读更多...
openGauss学习笔记-132 openGauss 数据库运维-查看openGauss状态

openGauss学习笔记-132 openGauss 数据库运维-查看openGauss状态

文章目录 openGauss学习笔记-132 openGauss 数据库运维-查看openGauss状态132.1 背景信息132.2 前提条件132.3 操作步骤132.4 参数说明132.5 示例 openGauss学习笔记-132 openGauss 数据库运维-查看openGauss状态 132.1 背景信息 openGauss支持查看整个openGauss的状态&#…
阅读更多...
【从亮机卡开始的云炼丹】环境配置记录debug

【从亮机卡开始的云炼丹】环境配置记录debug

要更改Anaconda环境的默认路径到D盘 可以按照以下步骤操作&#xff1a; 1. 打开Anaconda Prompt&#xff08;或者命令行窗口&#xff09;。 2. 输入以下命令更改Anaconda环境的默认路径到D盘&#xff1a; conda config --set envs_dirs D:\Anaconda\envs 这将把Anaconda环境…
阅读更多...
【挑战业余一周拿证】二、在云中计算 - 第 2 节 - Amazon EC2 实例类型

【挑战业余一周拿证】二、在云中计算 - 第 2 节 - Amazon EC2 实例类型

第 2 节 - Amazon EC2 实例类型 如果我们想让企业尽可能高效地运作&#xff0c;那就一定要确保员工的技能组合适合他们的角色&#xff0c;就 像我们的咖啡店有不同类型的员工一样&#xff0c;亚马逊云科技也有不同类型的 EC2 实例。每种实例类型 都归属于一个实例系列&#x…
阅读更多...
jQuery_08 each函数的使用

jQuery_08 each函数的使用

each函数的使用 可以循环数组&#xff0c;json&#xff0c;dom对象数组 1.$.each(要循环的内容,function(index,element){处理函数}) 要循环的内容可以是数组&#xff0c;json对象&#xff0c;dom数组 function&#xff1a;循环的处理函数 每个成员都会执行这个函数一次 index&…
阅读更多...
Rust语言入门教程(七) - 所有权系统

Rust语言入门教程(七) - 所有权系统

所有权系统是Rust敢于声称自己为一门内存安全语言的底气来源&#xff0c;也是让Rust成为一门与众不同的语言的所在之处。也正是因为这个特别的所有权系统&#xff0c;才使得编译器能够提前暴露代码中的错误&#xff0c;并给出我们必要且精准的错误提示。 所有权系统的三个规则…
阅读更多...
【Linux】Linux项目自动化构建工具 --- make / makefile

【Linux】Linux项目自动化构建工具 --- make / makefile

&#x1f466;个人主页&#xff1a;Weraphael ✍&#x1f3fb;作者简介&#xff1a;目前正在学习c和Linux还有算法 ✈️专栏&#xff1a;Linux &#x1f40b; 希望大家多多支持&#xff0c;咱一起进步&#xff01;&#x1f601; 如果文章有啥瑕疵&#xff0c;希望大佬指点一二 …
阅读更多...
tidyverse数据特征学习

tidyverse数据特征学习

目录 特征缩放 1&#xff0c;标准化-scale 2&#xff0c;归一化-rescale 3&#xff0c;行规范化 4&#xff0c;数据平滑 特征变换 1. 非线性特征 2. 正态性变换 3. 连续变量离散 特征降维 特征缩放 不同数值型特征的数据量纲可能相差多个数量级&#xff0c;这对很多…
阅读更多...
ZGC 垃圾回收过程

ZGC 垃圾回收过程

ZGC&#xff08;Z Garbage Collector&#xff09;是Java平台上的一种垃圾收集器&#xff0c;它是由Oracle开发的&#xff0c;旨在解决大堆的低延迟垃圾收集问题。ZGC是一种并发的分代垃圾收集器&#xff0c;它主要针对具有大内存需求和低停顿时间要求的应用程序 ZGC的核心概念及…
阅读更多...
人力资源管理后台 === 首页+部署

人力资源管理后台 === 首页+部署

目录 1.首页-echarts图表的应用 2.首页-echarts图表的按需导入 3.路由模式-将路由改成history模式 4. 打包分析-分析 5.CDN加速 6.项目打包-安装nginx 7.mac/windows环境下nginx部署启动项目 8.nginx解决history的404问题 9.nginx配置代理解决生产环境跨域问题 1.首页-…
阅读更多...
复数的几何意义

复数的几何意义

1、复平面&#xff0c;复数的其它表示法 (1)几何表示法 直角平面坐标&#xff1a; 复平面 实轴&#xff0c;虚轴 (2)向量表示法 向量 模&#xff1a; 复数加减法可用向量的三角形法则或者平行四边形法则 (3)结论 (两边之和大于第三边) ((两边之差大于第三边)) *辐角&am…
阅读更多...
「Verilog学习笔记」非整数倍数据位宽转换24to128

「Verilog学习笔记」非整数倍数据位宽转换24to128

专栏前言 本专栏的内容主要是记录本人学习Verilog过程中的一些知识点&#xff0c;刷题网站用的是牛客网 要实现24bit数据至128bit数据的位宽转换&#xff0c;必须要用寄存器将先到达的数据进行缓存。24bit数据至128bit数据&#xff0c;相当于5个输入数据第6个输入数据的拼接成一…
阅读更多...
Educational Codeforces Round 158 [Rated for Div. 2]

Educational Codeforces Round 158 [Rated for Div. 2]

A. Line Trip 还算比较简单的&#xff0c;不过本蒟蒻一开始以为是二分答案&#xff0c;二分写到一半突然想到油量直接取两个加油站之间的最大距离就好了。 最大距离能过&#xff0c;剩下必然都能过&#xff0c;要特判a[n]~x距离是两倍&#xff0c;因为x没有加油站&#xff0c…
阅读更多...
【Python百宝箱】Python项目生态圈：虚拟环境全指南

【Python百宝箱】Python项目生态圈：虚拟环境全指南

项目管理达人&#xff1a;Python虚拟环境的智慧选择 前言 在Python开发领域&#xff0c;创建虚拟环境是一项至关重要的任务&#xff0c;它有助于项目之间的依赖隔离&#xff0c;确保每个项目都能独立运行且使用特定的库和工具。本文将介绍多种创建Python虚拟环境的方法&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023