迷失的小鹿

mybatis-plus实战学习

mybatis-plus学习笔记

java中访问数据库各种方式的区别
mybatis-plus入门
- 开发步骤
- - 新建springboot工程
  - 添加maven依赖
  - 数据库配置
  - 实体类
  - 创建Dao接口
  - 在springboot的启动类上，加入Maper扫描器
  - 测试使用
配置mybatis日志
CRUD基本用法
ActiveRecord(AR）
- AR之insert
表和列
- 指定表名
- 驼峰命名
自定义sql
查询和分页
- 查询构造器：Wrapper
- QueryWrapper:查询条件封装类
- UpdateWrapper:更新条件封装类
查询
- allEq
- eq
- ne
- gt
- ge
- lt
- le
- between
- notBetween
- like,notlike
- likeLeft,liekRight
- isNull,isNotNull
- in,notIn
- inSql，notInSql
- groupBy
- orderByAsc，orderByDesc，orderBy
- or,and
- last
- exists,notExists
分页
通用service
- crud
- 分页查询
条件构造器
id生成策略
逻辑删除
数据自动填充
执行 SQL 分析打印
数据安全保护
乐观锁
代码生成器
- 快速入门
- 代码生成器（3.5.1+版本）快速入门
- 官网代码生成器(3.5.1+)
- - 数据库配置
  - 包配置

java中访问数据库各种方式的区别

mybatis-plus入门

开发步骤

新建springboot工程

添加maven依赖

pom依赖


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.5.6version>
        <relativePath/> 
    parent>
    <groupId>com.examplegroupId>
    <artifactId>demoartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>demoname>
    <description>Demo project for Spring Bootdescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starterartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-boot-starterartifactId>
            <version>3.4.3.4version>
        dependency>
        
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.27version>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.18.22version>
        dependency>
    dependencies>
project>

数据库配置

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
server:
  port: 9090

实体类

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

@Data
public class User {
    //定义属性，属性名和表中的列名一样
    /**
     * 指定主键的方式：
     * value:主键字段的名称，如果是id,可以不用写
     * type:指定主键的类型，主键的值如何生成,
     * IdType.AUTO表示自动增长
     */
    @TableId(value = "id",type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

创建Dao接口

Mapper

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User;

/**
 * 自定义Maper,就是Dao接口
 * 1、要实现BaseMapper
 * 2、指定实体类
 * BaseMapper是MP框架中的对象，定义17个操作方法(CRUD)
 */
public interface UserMapper extends BaseMapper<User> {
}

在springboot的启动类上，加入Maper扫描器

package com.example.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @MapperScan 注解，扫描器，指定Mapper类所在的包
 */
@SpringBootApplication
@MapperScan(value = "com.example.demo.mapper")
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

测试使用

在测试类或service注入Dao接口，框架实现动态代理创建Dao的实体类对象，
调用BaseMapper中的方法，完成CRUD
测试

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.List;

@SpringBootTest
class DemoApplicationTests {
    //使用自动注入，注入Mapper对象(Dao)
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testUser(){
        User user =new User();
        user.setName("张三");
        user.setAge(2);
        user.setEmail("[email protected]");
        //调用userMapper的方法，也就是父接口BaseMapper中提供的方法
        int rows = userMapper.insert(user);
        System.out.println("insert的结果:"+rows);
    }

}

输出insert的结果:1

配置mybatis日志

控制台输出正在执行的sql语句
application.yml

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

CRUD基本用法

insert

public void testUser(){
        User user =new User();
        user.setName("zhangsan");
        user.setAge(2);
        user.setEmail("[email protected]");
        //调用userMapper的方法，也就是父接口BaseMapper中提供的方法
        int rows = userMapper.insert(user);
        System.out.println("insert的结果:"+rows);
    }

//添加数据后，获取主键值
    @Test
    public void testInsertGetId(){
        User user =new User();
        user.setName("李斯");
        user.setAge(2);
        user.setEmail("[email protected]");
        int rows=userMapper.insert(user);
        System.out.println("insert的结果:"+rows);
        //获取刚添加到数据库中的数据的主键id
        System.out.println("主键id="+user.getId());
    }

update

 /**
     * 更新操作update
     */
    @Test
    public void testUpdate(){
        User user =new User();
        user.setName("修改的数据");
        user.setEmail("[email protected]");
        user.setId(6L);;
        /**
         * 执行更新，根据主键值更新
         * UPDATE user SET name=?, email=? WHERE id=?
         * 更新了所有非null属性值，根据WHERE id=主键值
         */
        int rows=userMapper.updateById(user);
        System.out.println("update rows: " +rows);
    }

/**
     * 控制更新的属性
     */
    @Test
    public void testUpdate2(){
        User user =new User();
        user.setId(2L);;
        user.setName("张三");
        /**
         * 更新属性
         * UPDATE user SET name=? WHERE id=?
         */
        int i = userMapper.updateById(user);
        System.out.println("i="+i);
    }

 /**
     * 更新数据，实体类的属性是基本类型-int age
     * 实体类属性：推荐使用包装类型，可以判断是否为null
     * 基本数据类型都有默认值，在不赋值的情况下，会在数据库中插入默认的值，
     */
    @Test
    public void testUpdate3(){
        User user =new User();
        user.setId(3L);
        user.setEmail("[email protected]");
        /**
         * 实体对象user:{name=null,email=”[email protected]“，age=0,
         * 没有修改name,age
         * 判断字段是否要修改，加入到set语句，是根据属性值是否为null
         *  UPDATE user SET age=?, email=? WHERE id=?
         */
        int rows = userMapper.updateById(user);
        System.out.println("rows="+rows);
    }

delete

 /**
     * 根据id删除
     * 按主键删除一条数据
     * 方法是deleteById()
     * 参数：主键值
     * 返回值：是删除的成功记录数
     */
    @Test
    public void testDelete(){
        //DELETE FROM user WHERE id=?
        int rows =userMapper.deleteById(3);
        System.out.println("rows="+rows);
    }

主键不存在的时候，删除0行

 /**
     * 按条件删除数据，条件是封装到Map对象中
     * 方法：deleteByMap（map对象）
     * 返回值：删除成功的记录数
     */
    @Test
    public void testDeleteMap(){
        //创建Map对象，保存条件值
        Map<String,Object> map=new HashMap<>();
        //put("表的字段名",条件值)
        map.put("name","zhangsan");
        map.put("age",2);
        //调用删除方法
        // DELETE FROM user WHERE name = ? AND age = ?
        int rows=userMapper.deleteByMap(map);
        System.out.println("rows="+rows);
    }

  /**
     * 批处理方式：使用多个主键值，删除数据
     * 方法民初：deleteBatchIds()
     * 参数：Collection idList
     * 返回值是删除的记录数
     */
    @Test
    public void testDeleteBatchIds(){
        List<Integer>ids=new ArrayList<>();
        ids.add(1);
        ids.add(5);
        ids.add(6);
        //DELETE FROM user WHERE id IN ( ? , ? , ? )
        int rows=userMapper.deleteBatchIds(ids);
        System.out.println("rows="+rows);
    }

使用lamda表达式创建list集合

/**
     * 批处理方式：使用多个主键值，删除数据
     * 方法民初：deleteBatchIds()
     * 参数：Collection idList
     * 返回值是删除的记录数
     */
    @Test
    public void testDeleteBatchIds(){
        //使用lamda表达式创建list集合
        List<Integer>ids= Stream.of(2,4).collect(Collectors.toList());
        //DELETE FROM user WHERE id IN ( ? , ? , ? )
        int rows=userMapper.deleteBatchIds(ids);
        System.out.println("rows="+rows);
    }

select

 /**
     *实现查询selectById，根据主键值查询
     * 参数：主键值
     *  返回值：实体对象(唯一的一个对象)
     */
    @Test
    public void testSelectById(){
        User user =userMapper.selectById(1);
        /**
         * SELECT id,name,age,email FROM user WHERE id=?
         * 如果根据主键没有查找到数据，得到的返回值是null
         */
        // 在使用对象之前，需要判断对象是否为null
        if(user!=null){
            //业务方法的调用
        }
        System.out.println("user="+user);
    }

  /**
     * 实现批处理查询，根据多个主键值查询，获取到list
     * 方法：selectBatchIds
     * 参数：id的集合
     * 返回值List
     */
    @Test
    public void testSelectBatchIds(){
        //lambda表达式
        //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )
        List<Integer>ids=Stream.of(4,8,9).collect(Collectors.toList());
        List<User>users=userMapper.selectBatchIds(ids);
        for (User user:users){
            System.out.println(user);
        }
    }

/**
     * 使用Map做条件查询
     * 方法：selectMap()
     * 参数：Mapkey为参数名，value为条件
     * 返回值:List
     */
    @Test
    public void testSelectMap(){
        //创建Map,封装查询条件
        Map<String,Object>map=new HashMap<>();
        //key是字段名，value:字段值，多个key,and连接
        map.put("name","zhangsan");
        map.put("age",20);
        List<User>users=userMapper.selectByMap(map);
        //SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
        users.forEach(user -> {
            System.out.println(user);
        });
    }

mybatis-plus的CRUD底层源码调用的是mybatis的SqlSession的方法

ActiveRecord(AR）

ActiveRecord

每一个数据库表对应创建一个类，类的每一个对象实力对应于数据库中表的一行记录；通常表的每个字段在类中都有相应的Field
ActiveRecord负责把自己持久化，在ActiveRecord中封装了对数据库的访问，通过对象自己实现CRUD,实现优雅的数据库操作
ActiveRecord也封装了部分业务逻辑，可以作为业务对象使用

AR之insert

1、dept表设计

2、entity实体类

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;

/**
 * 必须继承Model,Model定义了表的CRUD方法，Dept属性名和列名是一样的
 */
@Data
public class Dept extends Model<Dept> {
    @TableId(value = "id",type = IdType.AUTO)//自动增长，数据库中的字段为id
    private Integer id;
    private String name;
    private String mobile;
    private Integer manager;
}

3、Mapper

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.Dept;

/**
 * 不使用DeptMapper,也需要定义这个类，MP通过mapper获取表的结构
 * 不定义DeptMapper，MP会报错，找不到表的定义信息
 */
public interface DeptMapper extends BaseMapper<Dept> {
}

4、测试AR

package com.example.demo;

import com.example.demo.entity.Dept;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class DeptARTest {
    @Test
    public void testARInsert(){
        Dept dept = new Dept();
        dept.setName("销售部");
        dept.setMobile("010-12345678");
        dept.setManager(1);
        //调用实体对象自己的方法，完成对象自身到数据库的操作
        boolean flag = dept.insert();
        System.out.println("insert="+flag);
    }
}

@Test
    public void testUpdateById(){
        Dept dept =new Dept();
        dept.setId(3);
        dept.setManager(2);
        /**
         * 根据主键id更新数据
         * UPDATE dept SET manager=? WHERE id=?
         * 主键不能为空，否则更新失败
         * 主键在数据库中不存在，更新返回false
         * null的属性值不做更新处理，在update中没有null的字段
         */
        boolean flag =dept.updateById();
        System.out.println("update flag="+flag);
    }

 @Test
    public void testARDelete(){
        Dept dept =new Dept();
        dept.setId(1);
        /**
         * DELETE FROM dept WHERE id=?
         * deleteById()删除操作即使没有从数据库中删除数据，也返回是true
         * deleteById(1)传参，没有删除成功返回的是false
         */
        boolean flag = dept.deleteById();//拿实体自身的id作为删除的主键
        boolean result=dept.deleteById(1);
        System.out.println("删除是否成功:"+flag);
        System.out.println("result="+result);
    }

  @Test
    public void testSelectById(){
        Dept dept =new Dept();
        dept.setId(1);
        /**
         * SELECT id,name,mobile,manager FROM dept WHERE id=?
         * selectById
         * 1.按实体的主键能查出数据，返回对象
         * 2.按实体的主键不能查出数据，返回null,不报错
         */
        Model model=dept.selectById();
        System.out.println(model);
    }

    /**
     * selectById(主键)
     * 1.主键有记录，返回实体对象
     * 2.主键没有记录，返回是null,不报错
     * 3.主键参数为null,返回是null
     */
    @Test
    public void testSelect(){
        Dept dept =new Dept();
        Dept dept2=dept.selectById(null);
        System.out.println(dept2);
    }

表和列

主键，TableName,TableId
IdType枚举类，主键定义如下：

指定表名

表

实体类

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

/**
 * @TableName(value = "表名")
 */
@Data
@TableName(value = "address")
public class Address {
    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;
    /**
     *  @TableField:指定属性和列名的对应关系
     *  属性：value指定列名（数据库里对应的列名）
     */
    @TableField(value = "city")
    private String city;
    private String street;
    private String zipcode;
}

Mapper

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.Address;

public interface AddressMapper extends BaseMapper<Address> {
}

测试

package com.example.demo;

import com.example.demo.entity.Address;
import com.example.demo.mapper.AddressMapper;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class AddressTest {
    @Resource
    public AddressMapper addressMapper;
    @Test
    public void testInsert(){
        Address address = new Address();
        address.setCity("北京");
        address.setStreet("长安大街");
        address.setZipcode("010");
        int rows=addressMapper.insert(address);
        System.out.println("rows="+rows);
    }
}

驼峰命名

表

实体类

package com.example.demo.entity;

import lombok.Data;

@Data
public class Customer {
    private Integer id;
    private String custName;
    private String custEmail;
    private Integer custAge;
}

Mapper

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.Customer;

public interface CustomerMapper extends BaseMapper<Customer> {
}

测试

package com.example.demo;

import com.example.demo.entity.Customer;
import com.example.demo.mapper.CustomerMapper;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class CustomerTest {
    @Resource
    public CustomerMapper dao;
    @Test
    public void test(){
        Customer customer =new Customer();
        customer.setCustName("张三");
        customer.setCustAge(28);
        customer.setCustEmail("[email protected]");
        int rows=dao.insert(customer);
        System.out.println("rows="+rows);
        /**
         * INSERT INTO customer ( cust_name, cust_email, cust_age ) VALUES ( ?, ?, ? )
         * Parameters: 张三(String), [email protected](String), 28(Integer)
         * rows=1
         */
    }
}

自定义sql

表

实体类

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

@Data
public class Student {
    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;
    private String name;
    private Integer age;
    private String email;
    private Integer status;

}

Mapper

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.Student;

import java.util.List;

public interface StudentMapper extends BaseMapper<Student> {
    List<Student > selectByName();
    public int insertStudent(Student student);
    public Student selectStudentByName(String name);
}

新建sq映射文件


DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.StudentMapper">
    <select id="selectByName" resultType="com.example.demo.entity.Student">
        select id,name,age,email,status from student order by id limit 10
    select>
    <insert id="insertStudent" parameterType="com.example.demo.entity.Student">
        insert into student (name,age,email,status) values(#{name},#{age},#{email},#{status})
    insert>
    <select id="selectStudentByName" resultType="com.example.demo.entity.Student">
        select id,name,age,email,status from student where name =#{name}
    select>
mapper>

配置xml文件位置

测试

package com.example.demo;

import com.example.demo.entity.Student;
import com.example.demo.mapper.StudentMapper;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class StudentTest {
    @Resource
    private StudentMapper mapper;
    @Test
    public void testInsert(){
        /**
         * insert into student (name,age,email,status) values(?,?,?,?)
         */
        Student student = new Student();
        student.setName("李四");
        student.setEmail("[email protected]");
        student.setAge(20);
        student.setStatus(1);
        mapper.insertStudent(student);
    }
    @Test
    public void testSeectById(){
        /**
         * select id,name,age,email,status from student where name =?
         */
        Student student = mapper.selectStudentByName("李四");
        /**
         * SELECT id,name,age,email,status FROM student WHERE id=?
         */
        Student  stu = mapper.selectById(2);
        System.out.println(stu);
        if(stu!=null){
            //其他业务操作
        }
        System.out.println(student);
    }
}

查询和分页

查询构造器：Wrapper

在idea中ctr+N搜索Wrapper，鼠标选中Wrapper,ctrl+f12查看当前类的结构信息

条件	说明
allEq	基于map的相等
eq	等于=
ne	不等于<>
gt	大于>
ge	大于等于
lt	小于
le	小于等于
betwen	betwen 值1 and 值2
notBetween	not betwen 值1 and 值2
like	Like ‘%值%’
notLike	not like ‘%值%’
likeLeft	like’%值’
likeRight	like ‘值%’
isNull	字段 is null
isNotNull	字段 is not null
in	字段 in (value1,value2,…)
notIn	字段 not in (value1,value2,…)
inSql	字段 in (sql语句)
notInSql	字段 NOT IN ( sql语句 )
groupBy	GROUP BY 字段
orderByAsc	ORDER BY 字段, … ASC
orderByDesc	ORDER BY 字段, … DESC
orderBy	ORDER BY 字段, …例: orderBy(true, true, “id”, “name”)—>order by id ASC,name ASC
having	HAVING ( sql语句 ) 条件分组
or	or 语句,拼接 +OR 字段=值
and	And语句，拼接+AND 字段=值
apply	拼接sql
last	在sql语句后拼接自定义条件
exists	拼接exists(sql语句)exists(“select id from table where age = 1”)—>exists (select id from table where age = 1)
notExists	拼接 NOT EXISTS ( sql语句 )
nested	正常嵌套不带and或者or

QueryWrapper:查询条件封装类

方法	说明
select	设置查询字段select后面的内容

UpdateWrapper:更新条件封装类

方法	说明
set	设置要更新的字段，MP拼接sql语句
setSql	参数是sql语句，MP不在处理语句

查询

Student表：初始数据

allEq

以Map为参数条件
1、条件:name是张三，age=22

 @Test
    public void testAllEq(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        Map<String,Object>map=new HashMap<>();
        map.put("name","张三");
        map.put("age",22);
        //组装条件
        queryWrapper.allEq(map);
        /**
         * Map,key:对应列名，value:查询的值
         * SELECT id,name,age,email,status FROM student WHERE (name = ? AND age = ?)
         * Parameters: 张三(String), 22(Integer)
         *输出
         * Student(id=3, name=张三, age=22, [email protected], status=1)
         */
        List<Student>students=mapper.selectList(queryWrapper);//调用mp自己的查询方法
        students.forEach(student -> {
            //循环遍历输出
            System.out.println(student);
        });
    }

 @Test
    public void testAllEq2(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        Map<String,Object>map=new HashMap<>();
        map.put("name","张三");
        map.put("age",null);
        //组装条件
        /**
         * Map对象中有key的value是null
         * 使用的是queryWrapper.allEq(map,true)
         * 结果：
         * SELECT id,name,age,email,status FROM student WHERE (name = ? AND age IS NULL)
         * 如果使用的是使用的是queryWrapper.allEq(map,false)
         * 结果：
         *  SELECT id,name,age,email,status FROM student WHERE (name = ?)
         *  结论：
         *  allEq(map,boolean)
         *  true:处理null值，where条件加入字段 is null
         *  false:忽略null,不作为where条件
         */
        queryWrapper.allEq(map,false);
        List<Student>students=mapper.selectList(queryWrapper);//调用mp自己的查询方法
        students.forEach(stu-> System.out.println(stu));
    }

eq

等于 =
name等于李四

@Test
    public void testEq(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        /**
         * eq使用
         * eq("列名",值)
         * SELECT id,name,age,email,status FROM student WHERE (name = ?)
         */
        //组成条件
        queryWrapper.eq("name","张三");
        List<Student>students=mapper.selectList(queryWrapper);//调用mp自己的查询方法
        students.forEach(stu-> System.out.println(stu));
    }

ne

ne 不等于

  @Test
    public void testNe(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        /**
         * ne(列名，值)
         * ne不等于
         * SELECT id,name,age,email,status FROM student WHERE (name <> ?)
         */
        queryWrapper.ne("name","张三");
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

gt

gt大于

@Test
    public void testGt(){
        /**
         *SELECT id,name,age,email,status FROM student WHERE (age > ?)
         */
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age",20);
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

ge

ge大于等于

 @Test
    public void testGe(){
        /**
         *SELECT id,name,age,email,status FROM student WHERE (age >= ?)
         */
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.ge("age",30);
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

lt

lt小于

 @Test
    public void testLt(){
        /**
         *SELECT id,name,age,email,status FROM student WHERE (age < ?)
         */
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.lt("age",30);
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

le

le小于等于

@Test
    public void testLe(){
        /**
         *SELECT id,name,age,email,status FROM student WHERE (age <= ?)
         */
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.le("age",30);
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

between

between 在两个值范围之间（包括开始区间和结束区间）

 @Test
    public void testBetween(){
        /**
         *SELECT id,name,age,email,status FROM student WHERE (age BETWEEN ? AND ?)
         * 等于SELECT id,name,age,email,status FROM student WHERE age>=18 and age<=28
         * between("列名",开始值,结束值)
         */
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.between("age",18,28);
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

notBetween

不在范围区间内

@Test
    public void testNotBetween(){
        /**
         * SELECT id,name,age,email,status FROM student WHERE (age NOT BETWEEN ? AND ?)
         * 等于
         * SELECT id,name,age,email,status FROM student WHERE age<18 or age>28
         */
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.notBetween("age",18,28);
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

like,notlike

like 匹配值 “%值”
notLike 不匹配"%值"

 @Test
    public void testLike(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name","张");
        /**
         * ==>  Preparing: SELECT id,name,age,email,status FROM student WHERE (name LIKE ?)
         * ==> Parameters: %张%(String)
         * <==    Columns: id, name, age, email, status
         * <==        Row: 3, 张三, 22, [email protected], 1
         * <==      Total: 1
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

@Test
    public void testNotLike(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.notLike("name","张");
        /**
         Preparing: SELECT id,name,age,email,status FROM student WHERE (name NOT LIKE ?)
         Parameters: %张%(String)
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

likeLeft,liekRight

likeLeft:LIKE ‘%值’
likeRight:LIKE ‘值%’

 @Test
    public void testLikeLeft(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.likeLeft("name","张");
        /**
         SELECT id,name,age,email,status FROM student where name  like '%张'
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }
    @Test
    public void testLikeRight(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.likeRight("name","张");
        /**
         SELECT id,name,age,email,status FROM student where name  like '张%'
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

isNull,isNotNull

isNull:字段 IS NULL
isNotNull:字段 IS NOT NULL

@Test
    public void testIsNull(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("email");
        /**
         SELECT id,name,age,email,status FROM student WHERE (email IS NULL)
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }
    @Test
    public void testIsNotNull(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.isNotNull("email");
        /**
         SELECT id,name,age,email,status FROM student WHERE (email IS NOT NULL)
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

in,notIn

in后面值列表，在列表中都是符合条件的
notIn 不在列表中的

    @Test
    public void testIn(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.in("name","张三","李四");
        /**
         Preparing: SELECT id,name,age,email,status FROM student WHERE (name IN (?,?))
        Parameters: 张三(String), 李四(String)
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }
    @Test
    public void testNotIn(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.notIn("name","张三","李四");
        /**
         Preparing: SELECT id,name,age,email,status FROM student WHERE (name NOT IN (?,?))
         Parameters: 张三(String), 李四(String)
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

inSql，notInSql

inSql常用来做子查询类似 in()
notInSql 类似notIn()

 @Test
    public void testInSql(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.inSql("age","select age from student where id = 1");
        /**
         SELECT id,name,age,email,status FROM student WHERE (age IN (select age from student where id = 1))
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }
    @Test
    public void testNotInSql(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.notInSql("age","select age from student where id = 1");
        /**
         SELECT id,name,age,email,status FROM student WHERE (age not IN (select age from student where id = 1))
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

groupBy

groupBy基于多个字段分组

 @Test
    public void testGroupBy(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.select("name,count(*) personNumbers");
        queryWrapper.groupBy("name");
        /**
         * groupBy 分组
         *  SELECT name,count(*) personNumbers FROM student GROUP BY name
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

orderByAsc，orderByDesc，orderBy

orderByAsc 按字段降序
orderBy 每个字段指定排序方向

   @Test
    public void testOrderBy(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        //orderBy(条件内容是否添加到sql语句后面，true为添加，false为不添加)
        queryWrapper.orderBy(true,true,"name");
        /**
         * orderBy 指定字段和排序方向
         *SELECT id,name,age,email,status FROM student ORDER BY name ASC
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }
    @Test
    public void testOrderBy2(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        //添加多个排序字段
        queryWrapper.orderBy(true,true,"name")
        .orderBy(true,true,"email");
        /**
         * orderBy 指定字段和排序方向
         *SELECT id,name,age,email,status FROM student ORDER BY name ASC,email ASC
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

or,and

or 连接条件用or
and 连接条件用and

@Test
    public void testOr(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name","张三")
                .or()
                .eq("age",20);
        /*
        SELECT id,name,age,email,status FROM student WHERE (name = ? OR age = ?)
         Parameters: 张三(String), 20(Integer)
         */
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

last

last拼接sql语句

@Test
    public void testLst(){
       QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
       /*
       在sql语句最后面拼接sql语句
       Preparing: SELECT id,name,age,email,status FROM student WHERE (name = ? OR age = ?) limit 1
       Parameters: 张三(String), 20(Integer)
        */
       queryWrapper.eq("name","张三")
               .or()
               .eq("age",20)
               .last("limit 1");
       List<Student>students=mapper.selectList(queryWrapper);
       students.forEach(student -> System.out.println(student));
   }

exists,notExists

exists 拼接 EXISTS ( sql语句 )
notExists：是相反的操作

  @Test
    public void testExist(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
       /*
       SELECT id,name,age,email,status FROM student WHERE (EXISTS (select id from student where age>20))
        */
        queryWrapper.exists("select id from student where age>20");
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }
    @Test
    public void testNotExist(){
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
       /*
       SELECT id,name,age,email,status FROM student WHERE (NOT EXISTS (select id from student where age>20))
        */
        queryWrapper.notExists("select id from student where age>20");
        List<Student>students=mapper.selectList(queryWrapper);
        students.forEach(student -> System.out.println(student));
    }

分页

前提：配置分页插件，实现物理分页。默认是内存分页
由于springBoot启动类本身也是一个配置类（@Configuration修饰的类)
可以在springBoot启动类里main方法下面配置分页

package com.example.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @MapperScan 注解，扫描器，指定Mapper类所在的包
 */
@SpringBootApplication
@MapperScan(value = "com.example.demo.mapper")
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

mybatis-plus 3.4.3.4配置分页插件如下

package com.example.demo.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Configuration标注的类相当于xml配置文件
 */
@Configuration
public class Config {
    /**
     * 定义方法，方法的返回值是java对象，这个对象是放入到spring容器中
     *  @Bean 等同于
     */
    // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //DbType.MYSQL:分页使用的语句是mysql类型
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

}

测试

    @Test
    public void testPage(){
        /**
         * 分页：
         * 1.统计记录数，使用count(1)
         * select count(1) from student
         * 2.实现分页，在sql语句的末尾加入limit 0,3
         * SELECT id,name,age,email,status FROM student LIMIT 3
         * 要点!! 分页返回的对象与传入的对象是同一个
         *@Param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位(你可以继承Page实现自己的分页对象)
         */
        QueryWrapper<Student>queryWrapper = new QueryWrapper<>();
        IPage<Student>page =new Page<>();
        //设置分页的数据
        page.setCurrent(1);//设置当前页为第一页
        page.setSize(3);//每页的记录数为3
        IPage<Student> result = mapper.selectPage(page,queryWrapper);
        //获取分页后的记录
        List<Student>students = result.getRecords();
        students.forEach(student -> {
            System.out.println(student);
        });
        //分页的信息
        System.out.println("size="+result.getSize());
        System.out.println(result.getPages());
        System.out.println("页数："+result.getPages());
        System.out.println("总记录数:"+result.getTotal());
        System.out.println("当前的页码："+result.getCurrent());
        System.out.println("每页的记录数:"+result.getSize());
        /**
         * 输出如下结果
         * size=3
         * 3
         * 页数：3
         * 总记录数:7
         * 当前的页码：1
         * 每页的记录数:3
         */
    }

mybati-plus官网分页的介绍

通用service

crud

package com.example.demo.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.demo.entity.Student;

/**
 * mybatis-plus封装的service层的crud接口：IService
 */
public interface StudentService extends IService<Student> {
}

package com.example.demo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.Student;
import com.example.demo.mapper.StudentMapper;
import com.example.demo.service.StudentService;
import org.springframework.stereotype.Service;

/**
 * service实现类
 * 继承mp提供通用的service基类
 * ServiceImpl
 *     2个泛型 1.StudentMapper Mapper接口
 *     2.Student 对应的实体类对象
 */
@Service
public class StudentServiceImpl extends ServiceImpl<StudentMapper,Student> implements StudentService{
}

测试

package com.example.demo;

import com.example.demo.entity.Student;
import com.example.demo.service.StudentService;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@SpringBootTest
public class serviceTest {
    @Resource
    private StudentService studentService;
    @Test
    public void getList(){
        /*
            SELECT id,name,age,email,status FROM student
         */
        List<Student> list=studentService.list();
        list.forEach(student -> System.out.println(student));
    }
    @Test
    public void query(){
        /*
            SELECT id,name,age,email,status FROM student WHERE id=?
         */
        Student student = studentService.getById(1);
        System.out.println(student);
    }
    @Test
    public void insetBath(){
        /*
        ==>  Preparing: INSERT INTO student ( name, age, email, status ) VALUES ( ?, ?, ?, ? )
==> Parameters: 测试1(String), 23(Integer), [email protected](String), 1(Integer)
==> Parameters: 测试2(String), 24(Integer), [email protected](String), 1(Integer)
         */
        List<Student>list =new ArrayList<>();
        Student student = new Student();
        student.setName("测试1");
        student.setEmail("[email protected]");
        student.setAge(23);
        student.setStatus(1);
        Student student2 = new Student();
        student2.setName("测试2");
        student2.setEmail("[email protected]");
        student2.setAge(24);
        student2.setStatus(1);
        list.add(student);
        list.add(student2);
        boolean rows = studentService.saveBatch(list);
        System.out.println("rows="+rows);
    }
    @Test
    public void testSaveOrUpdate(){
        /**
         * 执行的sql语句
         * SELECT id,name,age,email,status FROM student WHERE id=8
         * 返回 Total:1
         * 执行的sql语句
         * UPDATE student SET name=?, age=?, email=?, status=? WHERE id=?
         * Parameters: 测试2(String), 22(Integer), [email protected](String), 1(Integer), 8(Integer)
         * 会根据主键先查询，如果存在就更新，不存在就插入
         */
        Student stu = new Student(8,"测试2",22,"[email protected]",1);
        boolean flag = studentService.saveOrUpdate(stu);
        System.out.println("flag="+flag);
    }
    @Test
    public void testSaveOrUpdate2(){
        /**
         * 执行的sql语句
         * SELECT id,name,age,email,status FROM student WHERE id=8
         * 返回 Total:0
         * 执行的sql语句
         * INSERT INTO student ( id, name, age, email, status ) VALUES ( ?, ?, ?, ?, ? )
         * Parameters: 11(Integer), 测试11(String), 11(Integer), [email protected](String), 1(Integer)
         */
        Student stu = new Student(11,"测试11",11,"[email protected]",1);
        boolean flag = studentService.saveOrUpdate(stu);
        System.out.println("flag="+flag);
    }
    @Test
    public void removeById(){
        /**
         * 执行的sql语句
         * DELETE FROM student WHERE id IN ( ? , ? )
         * Parameters: 8(Integer), 9(Integer)
         */
        List<Integer>ids = Arrays.asList(8,9);
        boolean flag = studentService.removeByIds(ids);
        System.out.println("flag="+flag);
    }
}

分页查询

在配置好分页插件之后，分页查询才会生效

package com.example.demo;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.demo.entity.Student;
import com.example.demo.service.StudentService;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@SpringBootTest
public class serviceTest {
    @Resource
    private StudentService studentService;
    @Test
    public void page(){
        /*
           执行的sql语句
           SELECT COUNT(*) AS total FROM student
           SELECT id,name,age,email,status FROM student LIMIT 2
         */
        IPage<Student>iPage =new Page<>(1,2);
        IPage<Student>page = studentService.page(iPage);
        List<Student>list =page.getRecords();
        System.out.println(list);//[Student(id=1, name=丽斯, age=20, [email protected], status=1), Student(id=2, name=李四, age=20, [email protected], status=1)]
        System.out.println(page.getPages());//4
    }
}

条件构造器

package com.example.demo;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.demo.entity.Student;
import com.example.demo.service.StudentService;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@SpringBootTest
public class serviceTest {
    @Resource
    private StudentService studentService;
    @Test
    public void contextLoad(){
        QueryWrapper<Student>queryWrapper=new QueryWrapper<>();
        /*
        select():设置查询字段
        执行的sql语句：
            SELECT id,name,age,email,status FROM student WHERE age=0
         */
        queryWrapper.select("id","name","age","email","status")
        .eq("age",20);
        studentService.list(queryWrapper).forEach(student -> System.out.println(student));
    }
    @Test
    public void updateWrapperTest(){
        UpdateWrapper<Student>updateWrapper =new UpdateWrapper<>();
        updateWrapper.set("age",20)
                .eq("name","张三");
        boolean flag = studentService.update(updateWrapper);
        /*
            执行的sql语句：
            UPDATE student SET age=? WHERE (name = ?)
             Parameters: 20(Integer), 张三(String)
         */
        System.out.println("flag="+flag);

    }

    @Test
    public void queryWrapperTest() {
        QueryWrapper<Student> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(Student::getId, Student::getName, Student::getAge, Student::getEmail, Student::getStatus)
                .eq(Student::getAge, 20);
        studentService.list(queryWrapper).forEach(student -> System.out.println(student));
        /*
        lamda表达式
            执行的sql语句：
             SELECT id,name,age,email,status FROM student WHERE (age = ?)
             Parameters: 20(Integer)
         */
    }
}

id生成策略

全局id生成策略配置：
在全局配置文件中，配置id生成策略，就不需要在每个实体类上添加主键配置了

mybatis-plus:
  global-config:
    db-config:
      id-type: auto

逻辑删除

物理删除：在删除的时候，直接将数据从数据库中删除
逻辑删除：从逻辑层面控制删除，通常会在表里添加一个逻辑删除的字段比如enabled,is_delete,数据默认是有效的(值为1),当用户删除时将数据修改
update 0,在查询的时候就只查where enabled = 1,
1.需要添加逻辑删除的字段
2.局部单表逻辑删除，需要在对应的pojo类加入对应的逻辑删除标识字段

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;
    private String name;
    private Integer age;
    private String email;
    @TableLogic //代表逻辑删除
    private Integer status;

}

全局逻辑删除，如果进行了全局逻辑删除配置并且指定了，就可以不用在每个实体类中配置了 @TableLogic

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: status # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

测试
有逻辑删除，mp封装的list()会自动过滤逻辑删除状态为已删除的字段

package com.example.demo;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.demo.entity.Student;
import com.example.demo.service.StudentService;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@SpringBootTest
public class serviceTest {
    @Resource
    private StudentService studentService;
    @Test
    public void logicDel(){
        /**
         * 执行sql语句：
         * UPDATE student SET status=1 WHERE id=1 AND status=0
         */
        studentService.removeById(1);
    }
    @Test
    public void listTest(){
        /**
         * 执行的sql语句
         *  SELECT id,name,age,email,status FROM student WHERE status=0
         */
        List<Student>list=studentService.list();
        list.forEach(student -> System.out.println(student));
    }
}

数据自动填充

官网介绍

在实体类的属性上添加@TableField(fill = FieldFill.INSERT) ，标记填充字段

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;
    private String name;
    private Integer age;
    private String email;
    @TableLogic //代表逻辑删除
    private Integer status;
    // 创建时间：希望在添加是数据的时候填充：当前时间
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    //修改时间：希望在修改数据的时候填充当前时间
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

}

自定义实现类 MyMetaObjectHandler

package com.example.demo.component;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * mybatis-plus自动填充功能自定义接口
 */
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
      // 插入时：创建时间字段为当前时间
      this.setFieldValByName("createTime",new Date(),metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        // 修改时：修改时间字段为当前时间
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

测试

package com.example.demo;

import com.example.demo.entity.Student;
import com.example.demo.service.StudentService;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class AutoTest {
    @Resource
    private StudentService studentService;
    @Test
    public void test(){
        Student student = new Student();
        student.setName("张三");
        student.setAge(23);
        student.setStatus(0);
        student.setEmail("[email protected]");
        /**
         * 执行sql语句
         *  INSERT INTO student ( name, age, email, status, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
         *  Parameters: 张三(String), 23(Integer), [email protected](String), 0(Integer), 2021-11-22 21:35:43.928(Timestamp), null
         */
        studentService.save(student);
    }
    @Test
    public void update(){
        /**
         * 执行sql语句
         * PDATE student SET name=?, age=?, email=?, update_time=? WHERE id=? AND status=0
         * Parameters: 张三(String), 22(Integer), [email protected](String), 2021-11-22 21:14:41.971(Timestamp), 1(Integer)
         */
        Student student = new Student();
        student.setId(1);
        student.setName("张三");
        student.setAge(22);
        student.setStatus(0);
        student.setEmail("[email protected]");
        boolean flag = studentService.updateById(student);
        System.out.println("flag="+flag);
    }
}

执行 SQL 分析打印

添加maven依赖

 <dependency>
            <groupId>p6spygroupId>
            <artifactId>p6spyartifactId>
            <version>3.9.1version>
        dependency>

mysql中sql分析打印配置

spring:
  datasource:
    #url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    #driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
    url: jdbc:p6spy:mysql://127.0.0.1:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai

在resources目录下添加spy.properties，配置如下：

#3.2.1以上使用
modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
#3.2.1以下使用或者不配置
#modulelist=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2

执行测试语句

 @Test
    public void update(){
        /**
         * 执行sql语句
         * PDATE student SET name=?, age=?, email=?, update_time=? WHERE id=? AND status=0
         * Parameters: 张三(String), 22(Integer), [email protected](String), 2021-11-22 21:14:41.971(Timestamp), 1(Integer)
         */
        Student student = new Student();
        student.setId(1);
        student.setName("张三");
        student.setAge(22);
        student.setStatus(0);
        student.setEmail("[email protected]");
        boolean flag = studentService.updateById(student);
        System.out.println("flag="+flag);
    }

控制台输出，显示当前sql执行所消耗时间

数据安全保护

防止删库跑路
1.得到16位随机密钥

package com.example.demo;

import com.baomidou.mybatisplus.core.toolkit.AES;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class randomKeyTest {
    @Test
    public void test(){
        String randomKey = AES.generateRandomKey();
    }
}

2.根据密钥加密数据库连接信息

package com.example.demo;

import com.baomidou.mybatisplus.core.toolkit.AES;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class randomKeyTest {
    @Test
    public void test(){
        String randomKey = AES.generateRandomKey();
        String username = AES.encrypt("root",randomKey);
        String pwd = AES.encrypt("root",randomKey);
        System.out.println(username);
        System.out.println(pwd);
    }
}

3.修改配置文件

    username: mpw:3vOuDLOc1ZjXczflw9LCYA==
    password: mpw:3vOuDLOc1ZjXczflw9LCYA==
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver

4.在部署的时候需要解密
java -jar xxx.jar --mpw.key=你的16位随机密钥
官网介绍

乐观锁

官网介绍

1.修改表结构，添加version字段，默认为1

2.在实体类的字段上加上@Version注解

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;
    private String name;
    private Integer age;
    private String email;
    @TableLogic //代表逻辑删除
    private Integer status;
    // 创建时间：希望在添加是数据的时候填充：当前时间
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    //修改时间：希望在修改数据的时候填充当前时间
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
    @Version
    private Integer version;

}

3.配置乐观锁插件

package com.example.demo.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Configuration标注的类相当于xml配置文件
 */
@Configuration
public class Config {
    /**
     * 定义方法，方法的返回值是java对象，这个对象是放入到spring容器中
     *  @Bean 等同于
     */
    // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        // 添加乐观锁插件
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }

}

测试

package com.example.demo;

import com.example.demo.entity.Student;
import com.example.demo.service.StudentService;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class StudentVersionTest {
    @Resource
    private StudentService studentService;
    @Test
    public void testCAS(){
        // 线程1 age:50,version:1
        Student student1 = studentService.getById(1);
        student1.setAge(50);
        //线程2 age：100 version:1
        Student student2 = studentService.getById(1);
        student2.setAge(100);
        //update 50 version:2 where version1 = 数据库version
        System.out.println(studentService.updateById(student1));/true
        //update 100 version:2 where version1 = 数据库version
        System.out.println(studentService.updateById(student2));//false
        if(studentService.updateById(student1)){
            System.out.println("更新成功");
        }
        if(studentService.updateById(student2)){
            System.out.println("更新失败，请重新刷新页面并更新");
        }
    }
}

更新时候，需要设置version字段

代码生成器

官网教程
引入依赖

        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-generatorartifactId>
            <version>3.5.1version>
        dependency>

Generator源码地址
GitHub
Gitee
官方文档
Maven仓库坐标

快速入门

maven依赖


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.5.6version>
        <relativePath/> 
    parent>
    <groupId>com.examplegroupId>
    <artifactId>demoartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>demoname>
    <description>Demo project for Spring Bootdescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>1.2.8version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.27version>
        dependency>
        
        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-boot-starterartifactId>
            <version>3.4.3.4version>
        dependency>
        
        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-generatorartifactId>
            <version>3.5.1version>
        dependency>
        
        
        <dependency>
            <groupId>org.apache.velocitygroupId>
            <artifactId>velocity-engine-coreartifactId>
            <version>2.3version>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.18.22version>
            <scope>providedscope>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>
    <pluginRepositories>
        <pluginRepository>

            <id>alimaven spring pluginid>

            <name>alimaven spring pluginname>

            <url>https://maven.aliyun.com/repository/spring-pluginurl>

        pluginRepository>
    pluginRepositories>

project>

package com.example.demo.builder;

import lombok.Getter;
import lombok.Setter;

/**
 * 测试构建者模式代码生成器
 */
@Setter
@Getter
public class CodeGenerator {
    /**
     * 数据源配置
     */
    private String datasource;
    /**
     * 包配置
     */
    private String packageConfig;
    /**
     * 策略配置
     */
    private String strategyConfig;

    /**
     * 执行代码生成
     */
    public void execute(){
        System.out.println(datasource+" "+packageConfig+" "+strategyConfig);
    }
}

package com.example.demo.builder;

/**
 * 代码生成器构建者模式
 */
public class CodeGeneratorBuilder {
    private CodeGenerator codeGenerator;
    public CodeGeneratorBuilder(CodeGenerator codeGenerator){
        this.codeGenerator=codeGenerator;
    }
    public static CodeGeneratorBuilder create(String datasource){
        CodeGenerator cg = new CodeGenerator();
        cg.setDatasource(datasource);
        return new CodeGeneratorBuilder(cg);
    }
    public  CodeGeneratorBuilder packageConfig(String packageConfig){
        codeGenerator.setPackageConfig(packageConfig);
        return this;
    }
    public  CodeGeneratorBuilder strategyConfig(String strategyConfig){
        this.codeGenerator.setStrategyConfig(strategyConfig);
        return this;
    }
    public void execute(){
        codeGenerator.execute();
    }
}

测试

package com.example.demo.builder;

public class Test {
    public static void main(String[] args) {
        //普通模式
        CodeGenerator codeGenerator = new CodeGenerator();
        codeGenerator.setDatasource("mysql");
        codeGenerator.setPackageConfig("com.baomidou");
        codeGenerator.setStrategyConfig("驼峰命名");
        codeGenerator.execute();
        //构建者模式
        CodeGeneratorBuilder.create("mysql").packageConfig("com.baomidou").strategyConfig("驼峰命名").execute();

    }
}

输出

代码生成器（3.5.1+版本）快速入门

数据表创建语句

drop table if exists `t_simple`;
create table `t_simple`
(
    id          int  primary key  auto_increment comment 'id',
    name        varchar(50) comment '姓名',
    age         int comment '年龄',
    delete_flag tinyint(1) comment '删除标识1',
    deleted tinyint(1) comment '删除标识2',
    version     bigint comment '版本',
    create_time datetime comment '创建时间',
    update_time datetime comment '更新时间'
) COMMENT = '测试表';

package com.example.demo.generator;

import com.baomidou.mybatisplus.generator.FastAutoGenerator;

public class CodeGenerator {
    static final String URL = "jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf8";

    public static void main(String[] args) {
        FastAutoGenerator.create(URL, "root", "root")
                // 全局配置
                .globalConfig(builder -> builder.outputDir("D:\\code"))
                // 策略配置
                .strategyConfig(builder -> builder.addInclude("t_simple"))
                /*
               模板引擎配置，默认 Velocity 可选模板引擎 Beetl 或 Freemarker
              .templateEngine(new BeetlTemplateEngine())
              .templateEngine(new FreemarkerTemplateEngine())
            */
                //执行
                .execute();
    }
}

输出实体类，Mapper,Service,Controller如下

package com.baomidou.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;

/**
 * 
 * 测试表
 * 
 *
 * @author 作者
 * @since 2021-11-29
 */
@TableName("t_simple")
public class TSimple implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * id
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 删除标识1
     */
    private Boolean deleteFlag;

    /**
     * 删除标识2
     */
    private Boolean deleted;

    /**
     * 版本
     */
    private Long version;

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Boolean getDeleteFlag() {
        return deleteFlag;
    }

    public void setDeleteFlag(Boolean deleteFlag) {
        this.deleteFlag = deleteFlag;
    }

    public Boolean getDeleted() {
        return deleted;
    }

    public void setDeleted(Boolean deleted) {
        this.deleted = deleted;
    }

    public Long getVersion() {
        return version;
    }

    public void setVersion(Long version) {
        this.version = version;
    }

    public LocalDateTime getCreateTime() {
        return createTime;
    }

    public void setCreateTime(LocalDateTime createTime) {
        this.createTime = createTime;
    }

    public LocalDateTime getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(LocalDateTime updateTime) {
        this.updateTime = updateTime;
    }

    @Override
    public String toString() {
        return "TSimple{" +
        "id=" + id +
        ", name=" + name +
        ", age=" + age +
        ", deleteFlag=" + deleteFlag +
        ", deleted=" + deleted +
        ", version=" + version +
        ", createTime=" + createTime +
        ", updateTime=" + updateTime +
        "}";
    }
}

package com.baomidou.mapper;

import com.baomidou.entity.TSimple;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * 
 * 测试表 Mapper 接口
 * 
 *
 * @author 作者
 * @since 2021-11-29
 */
public interface TSimpleMapper extends BaseMapper<TSimple> {

}


DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.baomidou.mapper.TSimpleMapper">

mapper>

package com.baomidou.service;

import com.baomidou.entity.TSimple;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * 
 * 测试表 服务类
 * 
 *
 * @author 作者
 * @since 2021-11-29
 */
public interface ITSimpleService extends IService<TSimple> {

}

package com.baomidou.service.impl;

import com.baomidou.entity.TSimple;
import com.baomidou.mapper.TSimpleMapper;
import com.baomidou.service.ITSimpleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

/**
 * 
 * 测试表 服务实现类
 * 
 *
 * @author 作者
 * @since 2021-11-29
 */
@Service
public class TSimpleServiceImpl extends ServiceImpl<TSimpleMapper, TSimple> implements ITSimpleService {

}

package com.baomidou.controller;


import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.stereotype.Controller;

/**
 * 
 * 测试表 前端控制器
 * 
 *
 * @author 作者
 * @since 2021-11-29
 */
@Controller
@RequestMapping("/tSimple")
public class TSimpleController {

}

官网代码生成器(3.5.1+)

package com.example.demo.generator;

import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;

import java.util.Collections;

public class CodeGenerator {
    static final String URL = "jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf8&allowPublicKeyRetrieval=true&useSSL=false";

    public static void main(String[] args) {
        FastAutoGenerator.create(URL, "root", "root")
                .globalConfig(builder -> {
                    builder.author("baomidou") // 设置作者
                            .enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .outputDir("D://"); // 指定输出目录
                })
                .packageConfig(builder -> {
                    builder.parent("com.baomidou.mybatisplus.samples.generator") // 设置父包名
                            .moduleName("system") // 设置父包模块名
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml, "D://")); // 设置mapperXml生成路径
                })
                .strategyConfig(builder -> {
                    builder.addInclude("t_simple") // 设置需要生成的表名
                            .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                }).execute();
    }
}

文件夹格式

实体类

package com.baomidou.mybatisplus.samples.generator.system.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * 
 * 测试表
 * 
 *
 * @author baomidou
 * @since 2021-11-29
 */
@TableName("t_simple")
@ApiModel(value = "Simple对象", description = "测试表")
public class Simple implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty("id")
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    @ApiModelProperty("姓名")
    private String name;

    @ApiModelProperty("年龄")
    private Integer age;

    @ApiModelProperty("删除标识1")
    private Boolean deleteFlag;

    @ApiModelProperty("删除标识2")
    private Boolean deleted;

    @ApiModelProperty("版本")
    private Long version;

    @ApiModelProperty("创建时间")
    private LocalDateTime createTime;

    @ApiModelProperty("更新时间")
    private LocalDateTime updateTime;


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Boolean getDeleteFlag() {
        return deleteFlag;
    }

    public void setDeleteFlag(Boolean deleteFlag) {
        this.deleteFlag = deleteFlag;
    }

    public Boolean getDeleted() {
        return deleted;
    }

    public void setDeleted(Boolean deleted) {
        this.deleted = deleted;
    }

    public Long getVersion() {
        return version;
    }

    public void setVersion(Long version) {
        this.version = version;
    }

    public LocalDateTime getCreateTime() {
        return createTime;
    }

    public void setCreateTime(LocalDateTime createTime) {
        this.createTime = createTime;
    }

    public LocalDateTime getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(LocalDateTime updateTime) {
        this.updateTime = updateTime;
    }

    @Override
    public String toString() {
        return "Simple{" +
        "id=" + id +
        ", name=" + name +
        ", age=" + age +
        ", deleteFlag=" + deleteFlag +
        ", deleted=" + deleted +
        ", version=" + version +
        ", createTime=" + createTime +
        ", updateTime=" + updateTime +
        "}";
    }
}

数据库配置

添加指定数据库驱动依赖jar
数据库网络可用，云主机注意！防火墙、网络安全组对应端口是否开放
严禁使用数据库关键词命名
务必表字段添加注释
多schema非默认必须指定
查询数据库中某张表的字段

查询当前数据库中的表

包配置

生成当前项目目录
System.getProperty(“user.dir”)+“src/main/java”
定义父目录 parent - 自定义输出pathInfo
模块化输出指定parent动态路径

你可能感兴趣的:(java,mybatis)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
MyBatis 详解阿贾克斯的黎明 java mybatis
目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
HQL之投影查询归来朝歌 HQL Hibernate 查询语句投影查询
在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
Spring整合redis bylijinnan redis
pom.xml <dependencies>  <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2 在项目中出现了org.hiber
android动画效果不懂事的小屁孩 android动画
前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
js delete 删除机理以及它的内存泄露问题的解决方案换个号韩国红果果 JavaScript
delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露（其实还未删除）举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
Oracle将零干预分析加入网络即服务计划蓝儿唯美 oracle
由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
spring学习——springmvc（二） a-john springMVC
Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
POJ-2828-Buy Tickets aijuans ACM_POJ
POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
Java Ant build.xml详解 asia007 build.xml
1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台 --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
android按钮监听器的四种技术百合不是茶 android xml配置监听器实现接口
android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方; 1,activity中使用内部类实现接口 ,创建内部类实例使用add方法与java类似创建监听器的实例 myLis lis = new myLis(); 使用add方法给按钮添加监听器
软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。如今很多的公司
TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForge How do Attachement Anchor Wiki Syntax
the CollabNet user information center http://help.collab.net/ How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
【Redis四】Redis数据类型 bit1129 redis
概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
SSH2整合-附源码白糖_ eclipse spring tomcat Hibernate Google
今天用eclipse终于整合出了struts2+hibernate+spring框架。我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。补充1：项目中部分jar包不是最新版的，可能导
[转]开源项目代码的学习方法 braveCS 学习方法
转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html 1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
编程之美-子数组的最大和（二维） bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
读书笔记-3 chengxuyuancsdn jquery笔记 resultMap配置 ibatis一对多配置
1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
[物理与天文]物理学新进展 comsci
如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境怎么办呢?
Oracle 11g新特性:Automatic Diagnostic Repository daizj oracle ADR
Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。这两份log文
简单排序:选择排序 dieslrae 选择排序
public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
线程同步工具类 shuizhaosi888 同步工具类
同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
bleeding edge是什么意思 haojinghua DI
不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。 In computer science, bleeding edge is a term that
c中实现utf8和gbk的互转 jimmee c iconv utf8&gbk编码
#include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
在代码中获取Android theme中的attr属性值 OliveExcel android theme
Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西. 在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
基于Zookeeper的分布式共享锁 roadrunners zookeeper 分布式共享锁
首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。官
两个容易被忽略的MySQL知识 tomcat_oracle mysql
1、varchar(5)可以存储多少个汉字，多少个字母数字？　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
zoj 3827 Information Entropy(水题) 阿尔萨斯 format
题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&