清除IDEA缓存后，删除.m2文件后依旧无法解析依赖，在setting.xml中新增镜像后解决问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<mirrors>
    <mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>*,!jeecg,!jeecg-snapshots,!getui-nexus</mirrorOf>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
    </mirror>

    <mirror>
        <id>nexus-aliyun</id>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
    </mirror>
</mirrors>

Connection to node -1 could not be established. Broker may not be available.

卡夫卡配置文件中监听地址存在问题，未设置IP

数据库无法连接

1. 配置文件异常 例如：

   1 2 3 4 5 6 7

   spring: datasource: driver-class-name: com.mysql.jdbc.Driver Url: jdbc:mysql://:/WXDinner? username: password:

   但是下方的方式可以使用

   1 2 3 4

   spring.datasource.driver-class-name= com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://:/WXDinner?characterEncoding=UTF-8&useUnicode=true&useSSL=false&tinyInt1isBit=false spring.datasource.username= spring.datasource.password=

2. 没装连接用的jar包

SpringBoot测试

例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@RunWith(SpringRunner.class)
@SpringBootTest
public class SampleTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        System.out.println(("----- selectAll method test ------"));
        List<User> userList = userMapper.selectList(null);
        Assert.assertEquals(5, userList.size());
        userList.forEach(System.out::println);
    }

}

Service错误

未使用注释@Service,若使用serviceimp则应在impl中标注@Service

org.apache.ibatis.binding.BindingException: Invalid bound statement (not found)

mapper.java与mapper.xml文件名应相同

1

mapper-locations未配置正确

网站显示404

在网站根目录新建CNAME文件，文件中写入域名。

mybatis Plus 多表联合查询

//实体类package com.sk.skkill.entity;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

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

import java.io.Serializable;
import java.util.Date;
import java.util.List;


@TableName("orders")
@Data
public class Order implements Serializable
{
    public static final long  serialVersionUID =1L;
    private String id;
    private String orderName;
    private Date createTime;
    private Date updateTime;
    private String userID;

    @TableField(exist = false)
    private  List<Users>  listUsers;


    public Order(){

    }

    public Order(String id, String orderName) {
        this.id = id;
        this.orderName = orderName;
    }


}



//dao层
package com.sk.skkill.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sk.skkill.entity.Order;
import com.sun.javafx.collections.MappingChange;
import org.apache.ibatis.annotations.Select;

import java.util.List;
import java.util.Map;

public interface OrderMapper extends BaseMapper<Order>
{
List<Order> selectOrder();
int addOrder(Order order);

//多表联合查询 按条件orderID
@Select("select t1.*,t2.user_name,t2.nick_name from orders t1 LEFT JOIN  users t2  ON t1.user_id =t2.id WHERE t1.user_id= #{id}")
 List<Map<String,Object>> orderUserList(Page<Map<String,Object>> page,String id);

}

//service层
package com.sk.skkill.service;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.sk.skkill.entity.Order;

import java.util.List;
import java.util.Map;

public interface OrderService extends IService<Order>
{
    List<Order> selectOrder();
    int addOrder(Order order);
//    List<Map<String,Object>> orderUserList(Page<Map<String,Object>> page, String id);
    Page<Map<String,Object>> selectListPage(int current,int number,String id);
}
//serviceImpl层
package com.sk.skkill.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sk.skkill.entity.Order;
import com.sk.skkill.mapper.OrderMapper;
import com.sk.skkill.service.OrderService;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService
{

    @Override
    public List<Order> selectOrder() {
        return baseMapper.selectList(null);
    }

    @Override
    public int addOrder(Order order) {
        return baseMapper.insert(order);
    }



    @Override
    public Page<Map<String, Object>> selectListPage(int current, int number,String id) {
        //新建分页
        Page<Map<String,Object>> page =new Page<Map<String,Object>>(current,number);
        //返回结果
        return  page.setRecords(this.baseMapper.orderUserList(page,id));
    }


}
//controller层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package com.sk.skkill.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sk.skkill.entity.Order;
import com.sk.skkill.service.impl.OrderServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("order")
public class OrderController
{
    @Autowired
    private OrderServiceImpl service;

    @RequestMapping("selectOrder")
    public List<Order> selectOrder()
    {
        return service.selectOrder();
    }
    @RequestMapping("addOrder")
  public  int addOrder(Order order){
        order=new Order("FGGG","蒙牛MILK");
       return service.addOrder(order);

  }
  @RequestMapping("selectListPage")
    public  List<Map<String,Object>>   selectListPage(String id)
    {
        Page<Map<String, Object>> page = service.selectListPage(1, 2,id);
        return page.getRecords();
    }


}

MapperScan配置问题

在Application中著名包名，例

1

@MapperScan("com.InterviewPreparation.learning.MyBatisPlus.mapper")

写一个配置类，例

1
2
3
4
5
6
7
8
9
10
11
12
13

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author ZYZ
 * @date 2021/5/13 20:40
 * @Description
 */
@Configuration
@MapperScan(value = {"com.InterviewPreparation.learning.MyBatisPlus.mapper*"})
public class MybatisPlusConfig {

}

配置文件中表示

1

mapper-locations: classpath*:org/jeecg/modules/**/xml/*Mapper.xml

代码生成器使用

CRUD 接口

#Service CRUD 接口

说明:

• 通用 Service CRUD 封装IService (opens new window)接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
• 泛型 T 为任意实体对象
• 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
• 对象 Wrapper 为 条件构造器

#Save

1
2
3
4
5
6

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

#参数说明

#SaveOrUpdate

1
2
3
4
5
6
7
8

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

#参数说明

#Remove

1
2
3
4
5
6
7
8

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

#参数说明

#Update

1
2
3
4
5
6
7
8
9
10

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

#参数说明

#Get

1
2
3
4
5
6
7
8
9
10

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

#参数说明

#List

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

#参数说明

#Page

1
2
3
4
5
6
7
8

// 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

#参数说明

#Count

1
2
3
4

// 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

#参数说明

#Chain

#query

1
2
3
4
5
6
7
8

// 链式查询 普通
QueryChainWrapper<T> query();
// 链式查询 lambda 式。注意：不支持 Kotlin
LambdaQueryChainWrapper<T> lambdaQuery(); 

// 示例：
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();

#update

1
2
3
4
5
6
7
8

// 链式更改 普通
UpdateChainWrapper<T> update();
// 链式更改 lambda 式。注意：不支持 Kotlin 
LambdaUpdateChainWrapper<T> lambdaUpdate();

// 示例：
update().eq("column", value).remove();
lambdaUpdate().eq(Entity::getId, value).update(entity);

#Mapper CRUD 接口

说明:

• 通用 CRUD 封装BaseMapper (opens new window)接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
• 泛型 T 为任意实体对象
• 参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
• 对象 Wrapper 为 条件构造器

#Insert

1
2

// 插入一条记录
int insert(T entity);

#参数说明

#Delete

1
2
3
4
5
6
7
8

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

#参数说明

#Update

1
2
3
4

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

#参数说明

#Select

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

#参数说明

#mapper 层 选装件

说明:

选装件位于 com.baomidou.mybatisplus.extension.injector.methods 包下 需要配合Sql 注入器使用,案例(opens new window)
使用详细见源码注释(opens new window)

#AlwaysUpdateSomeColumnById(opens new window)

1

int alwaysUpdateSomeColumnById(T entity);

#insertBatchSomeColumn(opens new window)

1

int insertBatchSomeColumn(List<T> entityList);

#deleteByIdWithFill(opens new window)

1

int deleteByIdWithFill(T entity);

#条件构造器

说明:

• 以下出现的第一个入参boolean condition表示该条件是否加入最后生成的sql中，例如：query.like(StringUtils.isNotBlank(name), Entity::getName, name) .eq(age!=null && age >= 0, Entity::getAge, age)
• 以下代码块内的多个方法均为从上往下补全个别boolean类型的入参,默认为true
• 以下出现的泛型Param均为Wrapper的子类实例(均具有AbstractWrapper的所有方法)
• 以下方法在入参中出现的R为泛型,在普通wrapper中是String,在LambdaWrapper中是函数(例:Entity::getId,Entity为实体类,getId为字段id的getMethod)
• 以下方法入参中的R column均表示数据库字段,当R具体类型为String时则为数据库字段名(字段名是数据库关键字的自己用转义符包裹!)!而不是实体类数据字段名!!!,另当R具体类型为SFunction时项目runtime不支持eclipse自家的编译器!!!
• 以下举例均为使用普通wrapper,入参为Map和List的均以json形式表现!
• 使用中如果入参的Map或者List为空,则不会加入最后生成的sql中!!!
• 有任何疑问就点开源码看,看不懂函数的点击我学习新知识(opens new window)

警告:

不支持以及不赞成在 RPC 调用中把 Wrapper 进行传输

1. wrapper 很重
2. 传输 wrapper 可以类比为你的 controller 用 map 接收值(开发一时爽,维护火葬场)
3. 正确的 RPC 调用姿势是写一个 DTO 进行传输,被调用方再根据 DTO 执行相应的操作
4. 我们拒绝接受任何关于 RPC 传输 Wrapper 报错相关的 issue 甚至 pr

#AbstractWrapper

说明:

QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类
用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件
注意: entity 生成的 where 条件与 使用各个 api 生成的 where 条件没有任何关联行为

#allEq

1
2
3

allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

• 全部eq(或个别isNull)

个别参数说明:

params : key为数据库字段名,value为字段值
null2IsNull : 为true则在map的value为null时调用 isNull 方法,为false时则忽略value为null的

• 例1: allEq({id:1,name:"老王",age:null})—>id = 1 and name = '老王' and age is null
• 例2: allEq({id:1,name:"老王",age:null}, false)—>id = 1 and name = '老王'

1
2
3

allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull) 

个别参数说明:

filter : 过滤函数,是否允许字段传入比对条件中
params 与 null2IsNull : 同上

• 例1: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null})—>name = '老王' and age is null
• 例2: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null}, false)—>name = '老王'

#eq

1
2

eq(R column, Object val)
eq(boolean condition, R column, Object val)

• 等于 =
• 例: eq("name", "老王")—>name = '老王'

#ne

1
2

ne(R column, Object val)
ne(boolean condition, R column, Object val)

• 不等于 <>
• 例: ne("name", "老王")—>name <> '老王'

#gt

1
2

gt(R column, Object val)
gt(boolean condition, R column, Object val)

• 大于 >
• 例: gt("age", 18)—>age > 18

#ge

1
2

ge(R column, Object val)
ge(boolean condition, R column, Object val)

• 大于等于 >=
• 例: ge("age", 18)—>age >= 18

#lt

1
2

lt(R column, Object val)
lt(boolean condition, R column, Object val)

• 小于 <
• 例: lt("age", 18)—>age < 18

#le

1
2

le(R column, Object val)
le(boolean condition, R column, Object val)

• 小于等于 <=
• 例: le("age", 18)—>age <= 18

#between

1
2

between(R column, Object val1, Object val2)
between(boolean condition, R column, Object val1, Object val2)

• BETWEEN 值1 AND 值2
• 例: between("age", 18, 30)—>age between 18 and 30

#notBetween

1
2

notBetween(R column, Object val1, Object val2)
notBetween(boolean condition, R column, Object val1, Object val2)

• NOT BETWEEN 值1 AND 值2
• 例: notBetween("age", 18, 30)—>age not between 18 and 30

#like

1
2

like(R column, Object val)
like(boolean condition, R column, Object val)

• LIKE ‘%值%’
• 例: like("name", "王")—>name like '%王%'

#notLike

1
2

notLike(R column, Object val)
notLike(boolean condition, R column, Object val)

• NOT LIKE ‘%值%’
• 例: notLike("name", "王")—>name not like '%王%'

#likeLeft

1
2

likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)

• LIKE ‘%值’
• 例: likeLeft("name", "王")—>name like '%王'

#likeRight

1
2

likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)

• LIKE ‘值%’
• 例: likeRight("name", "王")—>name like '王%'

#isNull

1
2

isNull(R column)
isNull(boolean condition, R column)

• 字段 IS NULL
• 例: isNull("name")—>name is null

#isNotNull

1
2

isNotNull(R column)
isNotNull(boolean condition, R column)

• 字段 IS NOT NULL
• 例: isNotNull("name")—>name is not null

#in

1
2

in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)

• 字段 IN (value.get(0), value.get(1), …)
• 例: in("age",{1,2,3})—>age in (1,2,3)

1
2

in(R column, Object... values)
in(boolean condition, R column, Object... values)

• 字段 IN (v0, v1, …)
• 例: in("age", 1, 2, 3)—>age in (1,2,3)

#notIn

1
2

notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)

• 字段 NOT IN (value.get(0), value.get(1), …)
• 例: notIn("age",{1,2,3})—>age not in (1,2,3)

1
2

notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)

• 字段 NOT IN (v0, v1, …)
• 例: notIn("age", 1, 2, 3)—>age not in (1,2,3)

#inSql

1
2

inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)

• 字段 IN ( sql语句 )
• 例: inSql("age", "1,2,3,4,5,6")—>age in (1,2,3,4,5,6)
• 例: inSql("id", "select id from table where id < 3")—>id in (select id from table where id < 3)

#notInSql

1
2

notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)

• 字段 NOT IN ( sql语句 )
• 例: notInSql("age", "1,2,3,4,5,6")—>age not in (1,2,3,4,5,6)
• 例: notInSql("id", "select id from table where id < 3")—>id not in (select id from table where id < 3)

#groupBy

1
2

groupBy(R... columns)
groupBy(boolean condition, R... columns)

• 分组：GROUP BY 字段, …
• 例: groupBy("id", "name")—>group by id,name

#orderByAsc

1
2

orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)

• 排序：ORDER BY 字段, … ASC
• 例: orderByAsc("id", "name")—>order by id ASC,name ASC

#orderByDesc

1
2

orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)

• 排序：ORDER BY 字段, … DESC
• 例: orderByDesc("id", "name")—>order by id DESC,name DESC

#orderBy

1

orderBy(boolean condition, boolean isAsc, R... columns)

• 排序：ORDER BY 字段, …
• 例: orderBy(true, true, "id", "name")—>order by id ASC,name ASC

#having

1
2

having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)

• HAVING ( sql语句 )
• 例: having("sum(age) > 10")—>having sum(age) > 10
• 例: having("sum(age) > {0}", 11)—>having sum(age) > 11

#func

1
2

func(Consumer<Children> consumer)
func(boolean condition, Consumer<Children> consumer)

• func 方法(主要方便在出现if…else下调用不同方法能不断链)
• 例: func(i -> if(true) {i.eq("id", 1)} else {i.ne("id", 1)})

#or

1
2

or()
or(boolean condition)

• 拼接 OR

注意事项:

主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)

• 例: eq("id",1).or().eq("name","老王")—>id = 1 or name = '老王'

1
2

or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)

• OR 嵌套
• 例: or(i -> i.eq("name", "李白").ne("status", "活着"))—>or (name = '李白' and status <> '活着')

#and

1
2

and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

• AND 嵌套
• 例: and(i -> i.eq("name", "李白").ne("status", "活着"))—>and (name = '李白' and status <> '活着')

#nested

1
2

nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)

• 正常嵌套 不带 AND 或者 OR
• 例: nested(i -> i.eq("name", "李白").ne("status", "活着"))—>(name = '李白' and status <> '活着')

#apply

1
2

apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)

• 拼接 sql

注意事项:

该方法可用于数据库函数 动态入参的params对应前面applySql内部的{index}部分.这样是不会有sql注入风险的,反之会有!

• 例: apply("id = 1")—>id = 1
• 例: apply("date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")—>date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
• 例: apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2008-08-08")—>date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")

#last

1
2

last(String lastSql)
last(boolean condition, String lastSql)

• 无视优化规则直接拼接到 sql 的最后

注意事项:

只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用

• 例: last("limit 1")

#exists

1
2

exists(String existsSql)
exists(boolean condition, String existsSql)

• 拼接 EXISTS ( sql语句 )
• 例: exists("select id from table where age = 1")—>exists (select id from table where age = 1)

#notExists

1
2

notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)

• 拼接 NOT EXISTS ( sql语句 )
• 例: notExists("select id from table where age = 1")—>not exists (select id from table where age = 1)

#QueryWrapper

说明:

继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件
及 LambdaQueryWrapper, 可以通过 new QueryWrapper().lambda() 方法获取

#select

1
2
3

select(String... sqlSelect)
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)

• 设置查询字段

说明:

以上方法分为两类.
第二类方法为:过滤查询字段(主键除外),入参不包含 class 的调用前需要wrapper内的entity属性有值! 这两类方法重复调用以最后一次为准

• 例: select("id", "name", "age")
• 例: select(i -> i.getProperty().startsWith("test"))

#UpdateWrapper

说明:

继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件
及 LambdaUpdateWrapper, 可以通过 new UpdateWrapper().lambda() 方法获取!

#set

1
2

set(String column, Object val)
set(boolean condition, String column, Object val)

• SQL SET 字段
• 例: set("name", "老李头")
• 例: set("name", "")—>数据库字段值变为空字符串
• 例: set("name", null)—>数据库字段值变为null

#setSql

1

setSql(String sql)

• 设置 SET 部分 SQL
• 例: setSql("name = '老李头'")

#lambda

• 获取 LambdaWrapper
  在QueryWrapper中是获取LambdaQueryWrapper
  在UpdateWrapper中是获取LambdaUpdateWrapper

#使用 Wrapper 自定义SQL

注意事项:

需要mybatis-plus版本 >= 3.0.7 param 参数名要么叫ew,要么加上注解@Param(Constants.WRAPPER) 使用${ew.customSqlSegment} 不支持 Wrapper 内的entity生成where语句

#用注解

1
2

@Select("select * from mysql_data ${ew.customSqlSegment}")
List<MysqlData> getAll(@Param(Constants.WRAPPER) Wrapper wrapper);

#用XML

1
2
3
4

List<MysqlData> getAll(Wrapper ew);
<select id="getAll" resultType="MysqlData">
	SELECT * FROM mysql_data ${ew.customSqlSegment}
</select>

#kotlin使用wrapper

kotlin 可以使用 QueryWrapper 和 UpdateWrapper 但无法使用 LambdaQueryWrapper 和 LambdaUpdateWrapper
如果想使用 lambda 方式的 wrapper 请使用 KtQueryWrapper 和 KtUpdateWrapper

#链式调用 lambda 式

1
2
3
4
5
6
7
8
9
10
11
12
13

// 区分:
// 链式调用 普通
UpdateChainWrapper<T> update();
// 链式调用 lambda 式。注意：不支持 Kotlin 
LambdaUpdateChainWrapper<T> lambdaUpdate();

// 等价示例：
query().eq("id", value).one();
lambdaQuery().eq(Entity::getId, value).one();

// 等价示例：
update().eq("id", value).remove();
lambdaUpdate().eq(Entity::getId, value).remove();

Linux编程基础

[TOC]

1.1 从Unix到Linux

为了提升UNICS系统的性能与兼容性，采用高级语言对其进行重构，并确定该操作系统名称为UNIX，这就是最早的 UNIX 操作系统（相对于 Multics ，UNIX 具有单一的意思）

GNU通用公共许可协议（GNU GPL）是一个广泛被使用的自由软件许可协议条款，最初由Stallman为GNU计划而撰写，GPL授予程序接受人以下权利，或称“自由”：

⚫ 以任何目的运行此程序的自由；

⚫ 再发行复制件的自由；

⚫ 改进此程序，并公开发布改进的自由

1.2 Linux概述

Linux是一个类Unix（Unix-like）的操作系统，在1991年发行了它的第一个版本

1991年11月，芬兰赫尔辛基大学的学生 Linus Torvalds写了个小程序，取名为Linux，放在互联网上。

1993，在一批高水平黑客的参与下，诞生了Linux 1.0 版

1994年，Linux 的第一个商业发行版 Slackware 问世

1996年，美国国家标准技术局的计算机系统实验室确认 Linux 版本 1.2.13（由 Open Linux 公司打包）符合 POSIX 标准

1.3 GNU & Linux

1.4 Linux 内核

Linux内核采用的是双树系统

一棵是稳定树，主要用于发行

另一棵是非稳定树或称为开发树，用于产品开发和改进

Linux内核版本号由3位数字组成

2.2 Vi编辑器使用

1.vi的工作模式

输入模式：输入字符为命令，可进行删除、修改、存盘等操作 。

命令模式：输入字符作为文本内容。

末行模式：命令模式下输入“：/？”三个中任意一个，可移到屏幕最底一行。

（1）命令模式

输入模式下，按ESC可切换到命令模式，常用命令：

（2）输入模式

输入以下命令即可进入vi输入模式

2.Vi其他功能命令

（1）复制粘贴

（2）查找/替换

（3）环境设置

3.1 GCC编译器介绍

GCC是一个强大的工具集合，它包含了预处理器、编译器、汇编器、链接器等组件。它会在需要的时候调用其他组件。
输入文件的类型和传递给gcc的参数决定了gcc调用具体的哪些组件。

GCC 参数选项

Usage:

gcc [options] [filename]

Basic options:

3.2 GCC编译过程

1、预处理

2、编译成汇编代码

3、汇编成目标代码

4、链接

1.预处理

预处理：使用-E参数

gcc –E –o gcctest.i gcctest.c

使用wc命令比较预处理后的文件与源文件，可以看到两个文件的差异

2.编译成汇编代码

预处理文件—->汇编代码
使用-S说明生成汇编代码后停止工作

gcc –S –o gcctest.s gcctest.i

直接编译到汇编代码

gcc –S gcctest.c

3.编译成目标代码

汇编代码à目标代码

gcc –x assembler –c gcctest.s

直接编译成目标代码

gcc –c gcctest.c

使用汇编器生成目标代码

as –o gcctest.o gcctest.s

4.编译成执行代码

目标代码à执行代码

gcc –o gcctest gcctest.o

直接生成执行代码

gcc –o gcctest gcctest.c

3.3 GCC编译优化

优化编译选项有：

-O0
缺省情况，不优化

-O1

-O2

-O3

等等

3.4 头文件和库函数目录

1. GCC –I dir 参数使用

头文件和gcc不在同一目录下，用 –I dir指明头文件所在的目录。

#include <>：在默认路径“/usr/include”中搜索头文件

#include “”：在本目录中搜索

解决办法：

1. gcc opt.c –o opt –I ./

2. 修改main

   1 2 3

   #include <my.h> #include “my.h”

2. GCC创建函数库

函数库：公用函数定义为函数库，供其他程序使用。函数库分为静态库和动态库。

静态库：程序编译时会链接到目标代码中，程序运行时不再需要静态库。程序生成的可执行程序比较大。后缀名为“.a”

动态库：程序编译时不会链接到目标代码，在程序运行时载入，运行时需要动态库存在。动态库可方便多个程序共享一个函数库。后缀名为”.so”

函数库的生成：由编译过的.o文件生成。

创建静态库：

1.将需要生成函数库的函数执行gcc –c，生成.o文件

​ gcc –c hello.c

2.由.o文件创建静态库，静态库命名格式为：lib静态库名.a

​ ar -rv libmyhello.a hello.o

3. 使用静态库：在调用静态库的程序编译时指定静态库名

   $gcc –o hello main.c –L. –lmyhello

   $./hello

创建动态库：

1.由.o文件生成动态库，动态库的命名：lib动态库名.so

1
2
3

gcc –shared –fPIC –o libmyhello.so hello.o

gcc –shared –fPIC –o libmyhello.so hello.c （centos版本）

2.使用动态库：用gcc命令指定动态库名进行编译，编译之前需将动态库文件复制到系统默认库函数目录/usr/lib中或者设置搜索路径。 sudo ldconfig

1
2
3

gcc –o hello main.c –L. –lmyhello

gcc –o hello main.c –L. –lmyhello -Wl,-rpath=./

gdb commands

Gdb using

$gdb filename

gdb将装入名为filename的可执行文件。

在编译时需要使用-g选项

list

help

设置断点 break

显示断点信息 info breakpoints

清除已经定义的断点 clear

delete [bkpoints-num]删除指定/全部断点

print [bkpoints-num] 输出断点处变量的值

quit:退出gdb

实例

调试子命令总结

file ：装入想要调试的可执行文件

kill：终止正在调试的程序

list：列出正在执行的程序清单

next：执行一行代码但不进入函数内部

step：执行一行代码并进入函数内部

run： 执行当前正在调试的程序

quit：终止gdb调试

break：设置断点 （break 行号）

watch：设置观察点，观察表达式的值是否发

​ 生变化

info: 查看断点信息

info breakpoints、info watchpoints

info break 显示当前断点清单，包括到达

​ 断点处的次数等。

info files 显示被调试文件的详细信息。

info func 显示所有的函数名称。

info local 显示当函数中的局部变量信息。

info prog 显示被调试程序的执行状态。

info var 显示所有的全局和静态变量名称

delete: 删除某个或所有的断点

​ delete 断点号 或 delete

disable: 使断点失效（但仍存在）

enable: 使断点有效

clear: 清除断点信息

​ clear 断点所在行号

​ clear 函数入口

continue: 继续执行程序直到程序结束

5.1 Make 引入

Make的引入:

Ø文件数量太大,手工gcc编译不方便

Ø仅需要编译已经做了修改的源代码文件;其他文件只需要重新连接

Ø记录哪些文件已改变且需要编译，哪些文件仅仅需要连接很难

make & makefile

Multi-file project

IDE—Eclipse

make

make & makefile

makefile描述模块间的依赖关系；

make命令根据makefile对程序进行管理和维护；make判断被维护文件的时序关系

make

make [-f filename] [targetname]

使用方法：

v make 自动找当前目录下名为Makefile/makefile的文件

v make –f 文件名 找当前目录下指定文件名的文件

makefile的组成

• 显式规则：明确指出目标文件的生成规则
• 隐式规则：需要make自动推导的规则
• 变量定义：声明时赋值，引用时加”$”
• 文件指示：引用外部的文件
• 注释：#

Makefile的显式规则

规则
一条规则包含3个方面的内容，

1）要创建的目标（文件），

2）创建目标（文件）所依赖的文件列表；

3）通过依赖文件创建目标文件的命令组

规则一般形式

1
2
3
4
5
6
7

*target* ... : *prerequisites* ... 

*<tab>command* 

<tab>...

<tab>...

每条规则由一个带冒号的“依赖行”和一条或多条以tab开头的“命令行”组成

目标1 [目标2…]:[依赖文件列表]

[\t 命令]

…

ex:

1
2
3

*make_test:make_main.o* *wrtlog.o*

**<TAB>***gcc* *-o* *make_test* *make_main.o* *wrtlog.o*

冒号左边是目标,冒号右边是依赖文件

目标和依赖文件均是由字母、数字、句点和斜杠组成的字符串

目标或依赖文件的数目多于一个时，以空格分隔

一个简单的makefile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

edit : main.o kbd.o command.o display.o insert.o search.o files.o utils.o
	gcc -o edit main.o kbd.o command.o display.o insert.o \
	search.o files.o utils.o
main.o : main.c defs.h
	gcc -c main.c
kbd.o : kbd.c defs.h command.h
	gcc -c kbd.c
command.o : command.c defs.h command.h
	gcc -c command.c
display.o : display.c defs.h buffer.h
	gcc -c display.c
insert.o : insert.c defs.h buffer.h
	gcc -c insert.c
search.o : search.c defs.h buffer.h
	gcc -c search.c
files.o : files.c defs.h buffer.h command.h
	gcc -c files.c
utils.o : utils.c defs.h
	gcc -c utils.c

clean : 
	rm edit main.o kbd.o command.o display.o insert.o search.o files.o utils.o 

Make的工作过程

default goal
在缺省的情况下，make从makefile中的第一个目标开始执行

Make的工作过程类似一次深度优先遍历过程

Makefile的变量

自定义变量
例：

object=main.o Add.o Sub.o Mul.o Div.o

exe : $(object)

gcc -o exe $(object)

特殊变量

$@：表示目标文件；

$^：表示所有依赖目标的集合，以空格分隔；

$<：表示第一个依赖文件；

Makefile的隐式规则（自动推导）

make能够自动推导文件以及文件依赖关系后面的命令

例：

object=main.o Add.o Sub.o Mul.o Div.o

exe : $(object)

gcc -o $@ $(object)

main.o : def.h

Makefile的伪目标

lmakefile使用.PHONY关键字来定义一个伪目标，具体格式为：

.PHONY : 伪目标名称

例：

.PHONY : clean

clean :

​ rm $(object)

总结: C语言编程步骤

1. 编辑：vi ,emacs,gedit,Eclipse…
2. 编译： gcc
3. 调试：gdb
4. 运行： ./executable file
5. 项目管理：make

扩展

gdb命令

.o文件是二进制文件

雨课堂题目整理

文件I/O

1.1 文件属性

1. 文件属性数据结构struct stat ——文件控制块

1
2
3
4
5
6
7
8
9
10
11
12
13
14

struct stat {
  mode_t st_mode;   /*file type & mode*/
  ino_t   st_ino;     /*inode number (serial number)*/
  dev_t  st_rdev;    /*device number (file system)*/ 
  nlink_t  st_nlink;    /*link count*/
  uid_t   st_uid;     /*user ID of owner*/
  gid_t   st_gid;     /*group ID of owner*/
  off_t   st_size;     /*size of file, in bytes*/
  time_t  st_atime;    /*time of last access*/
  time_t  st_mtime;   /*time of last modification*/
  time_t  st_ctime;    /*time of lat file status change*/
  long   st_blksize;   /*Optimal block size for I/O*/
  long   st_blocks;   /*number 512-byte blocks allocated*/
};

命令查看：ls -l file

2. stat/fstat/lstat函数

获取文件属性

1
2
3
4
5
6
7
8

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

int stat(const char *file_name, struct stat *buf);
int fstat(int filedes, struct stat *buf);
int lstat(const char *file_name, struct stat *buf);
(Return: 0 if success; -1 if failure)

1.2 文件类型

**1.**文件类型

Unix/Linux系统支持的文件类型：

• Directory(d):目录文件
• Link(l):链接文件
• Pipe(p):管道文件
• Block Device(b):块设备文件
• Character Device(c):字符设备文件
• Regular(-):普通文件
• Socket(s):套接字文件

查看文件类型

使用命令：ls –l /dev/sda1

例2.1设计一个程序，要求列出当前目录下的文件信息，以及系统“/dev/sda1”和“/dev/lp0”的文件信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include<stdio.h>	                
#include<stdlib.h>                  	/*文件预处理，包含system函数库*/
int main () 
{ 
	int newret;
	printf("列出当前目录下的文件信息：\n"); 
	newret=system("ls -l"); 
	printf("列出\"dev/sda1\"的文件信息：\n"); 
	newret=system("ls /dev/sda1 -l");	/*列出“/dev/sda1”的文件信息*/
	printf("列出\"dev/ lp0\"的文件信息：\n"); 
	newret=system("ls /dev/lp0 -l");      	/*列出“/dev/ lp0”的文件信息*/
	return 0;
}

**2.**获取文件类型

st_mode存储文件类型和许可权限，形式如下：
type3 type2 type1 type0 suid sgid sticky rwx rwx rwx

用来确定文件类型的宏：
S_ISBLK – 测试块文件
S_ISCHR –　测试字符文件
S_ISDIR –　测试目录
S_ISFIFO –　测试FIFO
S_ISREG – 测试普通文件
S_ISLNK – 测试符号链接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
int main(int argc,char *argv[])
{ int i;  struct stat statbuf;  
   for(i=1;i<argc;i++)    
  { printf("%s:",argv[i]);    
    if(lstat(argv[i],&statbuf)==-1)  {  printf("error\n");  continue;  }
    if(S_ISDIR(statbuf.st_mode))          printf("%s is a directory\n",argv[i]);
    else      if(S_ISREG(statbuf.st_mode))        printf("%s is a regular file\n",argv[i]);
      else    if(S_ISBLK(statbuf.st_mode))         printf("%s is a block device\n",argv[i]);
        else  if(S_ISCHR(statbuf.st_mode))        printf("%s is a charcter device\n",argv[i]); 
        #ifdef S_ISLNK        
          else if (S_ISLNK(statbuf.st_mode))      printf("%s is a link file\n",argv[i]);
       #endif
       #ifdef S_ISSOCK       
         else if (S_ISSOCK(statbuf.st_mode))     printf("%s is a socket \n",argv[i]);
      #endif    
         else          printf("%s is an unknown type file \n",argv[i]);     
  }
}

1.3 文件存取权限

**1.**文件存取权限

读的权限：显示目录文件，进入目录

写的权限：目录下创建文件

执行的权限：显示目录文件，进入目录，创建文件

**2.**改变文件存取权限——命令

例2.3 设计一个程序，要求把系统中“/home/mylinux目录下的myfile文件权限，设置成文件所有者可读可写，其他用户只读权限。

1
2
3
4
5
6
7

#include<sys/types.h>		
#include<sys/stat.h>       
int main ()
{
	chmod("/home/mylinux/myfile",S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
	return 0;
}

1
2
3
4
5
6
7

chmod 函数
Change permissions of a file
#include <sys/types.h>
#include <sys/stat.h>
int chmod(const char *path, mode_t mode);
int fchmod(int fildes, mode_t mode);// 打开的文件
(Return: 0 if success; -1 if failure)

3. 改变文件存取权限

4. 默认文件存取权限——umask

新创建的文件和目录的默认权限是(root)

File: -rw-r–r– 644

Directory: drwxr-xr-x 755

Why?

umask: 包含未被设置为权限位的==八进制数字(即无x位（可执行位）)==。默认002为普通用户，022为root用户。666-644=022

例2.4 设计一程序，要求设置系统文件和目录的权限掩码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include<stdio.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<sys/types.h>
int main()
{	mode_t new_umask,old_umask;
	new_umask=0666;
	old_umask=umask(new_umask);
	printf("系统原来的权限掩码是：%o\n",old_umask);
	printf("系统新的权限掩码是：%o\n",new_umask);
	system("touch liu1");
	printf("创建了文件liu1\n");
	new_umask=0444;
	old_umask=umask(new_umask);
	printf("系统原来的权限掩码是：%o\n",old_umask);
	printf("系统新的权限掩码是：%o\n",new_umask);
	system("touch liu2");
	printf("创建了文件liu2\n");
	system("ls liu1 liu2 -l");
	return 0;
}

1
2
3
4
5
6
7

umask 函数
为进程设置文件存取权限屏蔽字，并返回以前的值
#include <sys/types.h>
#include <sys/stat.h>
mode_t umask(mode_t mask);
建立文件，文件的权限为0666-mask；
建立目录，目录权限为0777-mask。

1.4 文件其他属性

**1.chown/fchown/**lchown 函数

1
2
3
4
5
6
7
8

改变文件所有者
#include <sys/types.h>
#include <unistd.h>

int chown(const char *path, uid_t owner, gid_t group);
int fchown(int fd, uid_t owner, gid_t group);
int lchown(const char *path, uid_t owner, gid_t group);
(Return: 0 if success; -1 if failure)

2.获取文件存取时间——stat

1
2
3
4
5
6
7
8
9
10
11

#include<stdio.h>
#include<sys/stat.h>
#include<time.h>
main()
{
 char *path="./2-5.c";
 struct stat statbuf;
 if (stat(path,&statbuf)==-1)
   perror("Failed to get file status");
 else printf("%s last accessed at %s",path,ctime(&statbuf.st_atime));
}

**3.**获取文件大小——stat

1
2
3
4
5
6
7
8
9
10
11

#include<stdio.h> 
#include<unistd.h>		
#include<sys/stat.h>     	
int main ()                 	
{
	struct stat buf;
	stat("/etc/passwd",&buf);
	printf("\"/etc/passwd\"文件的大小是：%d\n",buf.st_size);
	return 0;
}

2.1 两种I/O方式

1. 无缓冲和缓冲I/O

无缓冲I/O

• read/write ->系统函数
• 文件描述符
• POSIX.1 and XPG3标准

缓冲 I/O

1. 标准I/O库实现
2. 处理很多细节, 如缓存分配, 以优化长度执行I/O等.
3. 流 -> FILE类型指针

**2.**无缓冲 I/O 系统调用

基本 I/O

• open/creat, close, read, write, lseek
• dup/dup2
• fcntl

2.2 文件描述符

1.文件描述符概述

非负整数

​ int fd;

​ (in <unistd.h>)

​ STDIN_FILENO (0), STDOUT_FILENO (1), STDERR_FILENO (2)

文件操作一般步骤：

open-read/write-[lseek]-close

2. 进程打开文件的内核数据结构

2.3 无缓冲 I/O函数

**0.**错误处理

1
2
3
4
5
6
7
8
9
10

UNIX方式
Return value
“errno”变量( defined in /usr/include/errno.h)
extern int errno;

strerror & perror
#include <string.h>
char *strerror(int errnum);
#include <stdio.h>
void perror(const char *msg);

1. creat 函数

1
2
3
4
5
6

create a file or device 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
int creat(const char *pathname, mode_t mode);
(Return: a new file descriptor if success; -1 if failure)

例2.7 **设计一程序，要求在“/**home”目录下创建一个名称为“2-7file”的文件，并且把此文件的权限设置为所有者具有只读权限，最后显示此文件的信息。

1
2
3
4
5
6
7
8
9
10

#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
int main()
{
	int fd;
	fd=creat("./2-7file",S_IRUSR); 
	system("ls ./2-7file -l");
	return 0;
}

参数 “mode”

“mode”: 指定创建的新文件的存取权限

参数 “mode” & umask

umask: 一种文件保护机制

新建文件的初始存取权限

2. Open 函数

1
2
3
4
5
6
7
8

Open and possibly create a file or device 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode); 
(Return: a new file descriptor if success; -1 if failure)

例2.8设计一个程序，要求在当前目录下以可读写方式打开一个名为“2-8file”的文件。如果该文件不存在，则创建此文件；如果存在，将文件清空后关闭。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include<stdio.h>			
#include<stdlib.h>        	
#include<fcntl.h>         	
int main ()                 	 
{	int fd;
	if((fd=open("./2-8file",O_CREAT|O_TRUNC|O_WRONLY,0600))<0)
	  { 	perror("打开文件出错");
		exit(1);
	  }
	else
	  {	printf("打开(创建)文件\"2-8file\"，文件描述符为：%d\n",fd);
	  }
	if(close(fd)<0)
	  {	perror("关闭文件出错");
		exit(1);
	  }
	system("ls ./2-8file -l");
	return 0;
}

参数 “flags”

1
2
3
4
5
6
7
8

“flags”: 指定文件存取方式
One of O_RDONLY, O_WRONLY or O_RDWR which request opening the file read-only, write-only or read/write, respectively, bitwise-or’d with zero or more of the following: ( All defined in /usr/include/fcntl.h)
O_APPEND: 追加方式打开
O_TRUNC:文件存在清空
O_CREAT: 文件不存在创建.
O_EXCL: 和 O_CREAT一起用时, 文件存在则出错，打开失败
…
“creat” function: 等价于open函数中指定 O_CREAT|O_WRONLY|O_TRUNC

3. close 函数

1
2
3
4

Close a file descriptor
#include <unistd.h>
int close(int fd);
(Return: 0 if success; -1 if failure)

4. read/write 函数

1
2
3
4
5
6
7
8

Read from a file descriptor
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
(返回值: 读到的字节数，若已到文件尾为0，若出错为-1)
Write to a file descriptor
#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);
(返回值: 若成功为已写的字节数，若出错为-1)

例2.9设计一个程序，完成文件的复制工作。要求通过read函数和write函数复制“/etc/passwd”文件到目标文件中，目标文件名在程序运行时从键盘输入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{	int fdsrc,fddes,nbytes; int z; char buf[20], des[20];
	int flags=O_CREAT | O_TRUNC | O_WRONLY;
	printf("请输入目标文件名:");	
 	scanf("%s",des);                 		
	fdsrc=open("/etc/passwd",O_RDONLY);	
	if(fdsrc<0)	{	exit(1);	}
	fddes=open(des,flags,0644);         	
	if(fddes<0)	{	exit(1);	}
	while((nbytes=read(fdsrc,buf,20))>0)
	   {	z=write(fddes,buf,nbytes);
	if(z<0)	{	perror("写目标文件出错");	}	}
	close(fddes);
	close(fdsrc);
	printf("复制\"/etc/passwd\"文件为\"%s\"文件成功！\n",des);
	exit(0);
}

5. lseek 函数

read/write 定位文件指针

1
2
3
4
5
6
7

#include <sys/types.h>

#include <unistd.h>

off_t lseek(int fildes, off_t offset, int whence);

(Return: the resulting offset location if success; -1 if failure)

该指令的“那里”:

​ SEEK_SET: the offset is set to “offset” bytes指针位移量为设定值

​ SEEK_CUR: the offset is set to its current location plus “offset” bytes指针位移量为当前位移加设定值

​ SEEK_END: the offset is set to the size of the file plus “offset” bytes指针位移量为文件尾加设定值

空洞文件

使用lseek修改文件偏移量后，当前文件偏移量有可能大于文件的长度

在这种情况下，对该文件的下一次写操作，将加长该文件

这样文件中形成了一个空洞。对空洞区域进行读，均返回0

6. dup/dup2 函数

1
2
3
4
5

复制文件描述符
#include <unistd.h>
int dup(int oldfd);
int dup2(int oldfd, int newfd);
(Return: the new file descriptor if success; -1 if failure)

假设进程已打开文件描述符0、1、2

调用dup2(1, 6)，dup2返回值是多少？

然后再调用dup(6)，dup返回值是多少？

7. fcntl函数

1
2
3
4
5
6

查看、修改打开的文件描述符
#include<fcntl.h>
#include<unistd.h>
#include<sys/types.h>
int result=fcntl(int fd,int cmd);
int result=fcntl(int fd,int cmd,long arg,…);

lcmd取值：

F_DUPFD 复制文件描述符

F_GETFD 获得文件描述符

F_SETFD 设置文件描述符

F_GETFL 获取文件描述符当前模式

F_SETFL设置文件描述符当前模式

F_GETLK 获得记录锁

F_SETLK 设置记录锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

分析以下程序运行情况
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
char buf1[]="abcdefghij";
char buf2[]="ABCDEFGHEIJ";
main()
{int fd;
 if((fd=open("file.hole",O_WRONLY|O_CREAT/*|O_APPEND*/,0644))<0) 
    perror("creat error");
 if(write(fd,buf1,10)!=10)
   perror("buf1 write error");
 if(lseek(fd,40,SEEK_SET)==-1) 
   perror("lseek error");
 if(write(fd,buf2,10)!=10)
   perror("buf2 write error");
 exit(0);
}
（1）ls –l 查看文件大小多少字节？
（2）cat 查看文件内容？
（3）od –c 查看文件内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

分析以下程序运行结果
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<unistd.h>
main()
{ int fd;
  if((fd=open("myout",O_WRONLY|O_CREAT,0644))==-1)
   perror("myout open error");
  if(dup2(fd,STDOUT_FILENO)==-1)
   perror("redirect stand output failed");
  printf("this is a test program for redirect\n");
  close(fd);
}
（1）查看程序运行结果？
（2）cat 查看文件myout的内容

3.1 标准I/O库

为什么要设计标准I/O库？

​ 直接使用API进行文件访问时，需要考虑许多细节问题

​ 例如：read、write时，缓冲区的大小该如何确定，才能使效率最优

标准I/O库封装了诸多细节问题，包括缓冲区分配

I/O效率示例

1
2
3
4
5
6
7
8
9
10
11
12
13

#define BUFFSIZE 4096
#include<stdio.h>
#include<unistd.h>
int main()
{  
  int n;
  char buf[BUFFSIZE];
  while((n = read(STDIN_FILENO, buf, BUFFSIZE))>0)       
     if(write(STDOUT_FILENO, buf,n)!= n)                   
       perror("write error");
  return 0;
}
程序中，影响效率的关键：BUFFSIZE的取值

原因

• Linux文件系统采用了某种预读技术
• 当检测到正在进行顺序读取时，系统就试图读入比应用程序所要求的更多数据
• 并假设应用程序很快就会读这些数据
• 当BUFFSIZE增加到一定程度后，预读就停止了

标准 I/O 缓冲

标准I/O库提供缓冲的目的：尽可能减少使用read、write调用的次数，以提高I/O效率。

通过标准I/O库进行的读写操作，数据都会被放置在标准I/O库缓冲中中转。

3.2 文件流

1
2
3
4
5
6
7
8
9

typedef struct  {
..............................        
char            fd;                        /* File descriptor      */
short           bsize;                  /* Buffer size          */
unsigned char   *buffer;        /* Data transfer buffer */
....................................
}       FILE;     
标准I/O库
管理的缓冲区

3.3 标准 I/O 函数

• 流 open/close
• 流 read/write
  • ​ 每次一个字符的I/O：fgetc,fputc
  • ​ 每次一行的I/O: fgets,fputs,gets,puts
  • ​ 直接I/O(二进制I/O): fread,fwrite
  • ​ 格式化I/O:scanf,printf,fscanf,fprintf
• 流定位:fseek,ftell,frewind
• 流刷新:fflush

1. 流打开/关闭

例2.10设计一个程序，要求用流文件I/O操作打开文件“2-10file”,如果该文件不存在，则创建文件。

1
2
3
4
5
6
7
8
9
10
11

#include<stdio.h>
#include<stdlib.h>
int main()
{
	FILE * fp;                                 		
	if((fp=fopen("./2-10file","a+"))==NULL)       	
	{
		printf("打开(创建)文件出错");      	exit(0);
	}
	fclose(fp);                                 		
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Open a stream
#include <stdio.h>
FILE *fopen(const char *filename, const char *mode);
Parameter “mode”
“r”:  	Open text file for reading.
“w”: Truncate file to zero length or create text file for writing.
“a”: 	Open for appending.
“r+”: Open for reading and writing.
“w+”: Open for reading and writing. The file is created if it does not exist, otherwise it is truncated.
“a+”: Open for reading and appending. The file is created if does not exist.
    
Close a stream
#include <stdio.h>
int fclose(FILE *fp);
(Return: 0 if success; -1 if failure)

**2.流读/**写

对流有三种读写方式

• 每次读写一个字符

• 每次读写一行

• 每次读写任意长度的内容

（1）输入/出一个字符

1
2
3
4
5
6
7
8
9
10
11

输入
#include <stdio.h>
int getc(FILE *fp);
int fgetc(FILE *fp);
int getchar(void);
输出
#include <stdio.h>
int putc(int c, FILE *fp);
int fputc(int c, FILE *fp);
int putchar(int c);
(Return: the character if success; -1 if failure)

（2） 输入/出一行

1
2
3
4
5
6

#include <stdio.h>
char *fgets(char *s, int size, FILE *stream);
char *gets(char *s);
#include <stdio.h>
int fputs(const char *s, FILE *stream);
int puts(const char *s);

（3） 二进制流输入/输出

1
2
3
4

#include <stdio.h>
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
size fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
(Return: the number of a items successfully read or written.)

例2.11设计两个程序，要求一个程序把三个人的姓名和账号余额信息通过一次流文件I/O操作写入文件“2-11file”，另一个格式输出账号信息，把每个人的账号和余额一一对应显示输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

/*程序：把帐号信息从文件读出*/  
#include<stdio.h>
#define nmemb 3
struct test						 
{	char name[20];
	int pay;
}s[nmemb];
int main( )
{	FILE * fp;              		
	int i;
	fp = fopen("2-11file", "r");	
	fread(s,sizeof(struct test),nmemb,fp); 
	fclose(fp);                  			 
	for(i=0;i<nmemb;i++)
		printf("帐号[%d]:%-20s余额[%d]:%d\n",i,s[i].name,i,s[i].pay);
	return 0;
}

/*程序：把帐号信息写入文件*/  
#include<stdio.h>
#include<string.h>
#define set_s(x,y,z) {strcpy(s[x].name,y);s[x].pay=z;}   /*自定义宏，用于赋值*/
#define nmemb 3
struct test                     	 
{	char name[20];
	int pay;
}s[nmemb];
int main()
{	FILE * fp;                   	
	set_s(0,"张三",12345);
	set_s(1,"李四",200);
	set_s(2,"王五",50000);
	fp=fopen("2-11file","a+");	/*打开(创建)文件*/
	fwrite(s,sizeof(struct test),nmemb,fp);
	fclose(fp);
	return  0;                    	
}

（4） 格式化 I/O

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int scanf(const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);
int sscanf(const char *str, const char *format, ...);

#include <stdio.h>
int printf(const char *format, ...);
int fprintf(FILE *stream, const char *format, ...);
int sprintf(char *str, const char *format, ...);

3.流定位

1
2
3
4

#include <stdio.h>
int fseek(FILE *stream, long int offset, int whence);
long ftell(FILE *stream);
void rewind(FILE *stream);