在我们开发的很多分布式项目里面(如基于WCF服务、Web
API服务方式),由于数据提供涉及到数据库的相关操作,如果客户端的并发数量超过一定的数量,那么数据库的请求处理则以爆发式增长,如果数据库服务器无法快速处理这些并发请求,那么将会增加客户端的请求时间,严重者可能导致数据库服务或者应用服务直接瘫痪。缓存方案就是为这个而诞生,随着缓存的引入,可以把数据库的IO耗时操作,转换为内存数据的快速响应操作,或者把整个页面缓存到缓存系统里面。缓存框架在各个平台里面都有很多的实现,基本上多数是采用分布式缓存Redis、Memcached来实现。本系列文章介绍在.NET平台中,使用开源缓存框架CacheManager来实现数据的缓存的整个过程,本篇主要介绍CacheManager的使用和相关的测试。

Python的创始人为吉多\范罗苏姆(Gudio van Rossum)*

引言  – 从”HelloWorld”开始

1、CacheManager的介绍

CacheManager是一个以C#语言开发的开源.Net缓存框架抽象层。它不是具体的缓存实现,但它支持多种缓存提供者(如Redis、Memcached等)并提供很多高级特性。
CacheManager
主要的目的使开发者更容易处理各种复杂的缓存场景,使用CacheManager可以实现多层的缓存,让进程内缓存在分布式缓存之前,且仅需几行代码来处理。
CacheManager
不仅仅是一个接口去统一不同缓存提供者的编程模型,它使我们在一个项目里面改变缓存策略变得非常容易,同时也提供更多的特性:如缓存同步、并发更新、序列号、事件处理、性能计算等等,开发人员可以在需要的时候选择这些特性。

CacheManager的GitHub源码地址为:,如果需要具体的Demo及说明,可以访问其官网:。

使用Nuget为项目添加CacheManager包引用。CacheManager包含了很多的Package.
其中CacheManager.Core是必须的,其它的针对不同缓存平台上有不同的对应Package,整个Nuget包包含下面几个部分的内容。

澳门微尼斯人手机版 1

CacheManager缓存框架支持Winform和Web等应用开发,以及支持多种流行的缓存实现,如MemoryCache、Redis、Memcached、Couchbase、System.Web.Caching等。

纵观整个缓存框架,它的特定很明显,在支持多种缓存实现外,本身主要是以内存缓存(进程内)为主,其他分布式缓存为辅的多层缓存架构方式,以达到快速命中和处理的机制,它们内部有相关的消息处理,使得即使是分布式缓存,也能够及时实现并发同步的缓存处理。

在网上充斥着基于某种单独缓存的实现和应用的趋势下,这种更抽象一层,以及提供更高级特性的缓存框架,在提供了统一编程模型的基础上,也实现了非常强大的兼容性,使得我一接触到这个框架,就对它爱不释手。

在GitHub上,缓存框架的前几名,除了这个缓存框架外,也还有一些,不过从文档的丰富程度等各方面来看,这个缓存框架还是非常值得拥有的。

CacheManager缓存框架在配置方面,支持代码方式的配置、XML配置,以及JSON格式的配置处理,非常方便。

CacheManager缓存框架默认对缓存数据的序列化是采用二进制方式,同时也支持多种自定义序列化的方式,如基于JOSN.NET的JSON序列化或者自定义序列化方式。

CacheManager缓存框架可以对缓存记录的增加、删除、更新等相关事件进行记录。

CacheManager缓存框架的缓存数据是强类型的,可以支持各种常规类型的处理,如Int、String、List类型等各种基础类型,以及可序列号的各种对象及列表对象。

CacheManager缓存框架支持多层的缓存实现,内部良好的机制可以高效、及时的同步好各层缓存的数据。

CacheManager缓存框架支持对各种操作的日志记录。

CacheManager缓存框架在分布式缓存实现中支持对更新的锁定和事务处理,让缓存保持更好的同步处理,内部机制实现版本冲突处理。

CacheManager缓存框架支持两种缓存过期的处理,如绝对时间的过期处理,以及固定时段的过期处理,是我们处理缓存过期更加方便。

….

很多特性基本上覆盖了缓存的常规特性,而且提供的接口基本上也是我们所经常用的Add、Put、Update、Remove等接口,使用起来也非常方便。

 

澳门微尼斯人手机版 2

  Makefile 是Linux C 程序开发最重要的基本功.
代表着整个项目编译和最终生成过程.本文重点是带大家了解真实项目中那些简易的Makefile规则构建.

2、CacheManager缓存框架的应用

通过上面对CacheManager缓存框架的简单了解,我们大概了解了它应用的一些功能,但是实际上我们如何使用它,我们需要做一些学习和了解,首先我们需要在整个应用框架里面,知道缓存框架所扮演的角色。

一般来说,对于单机版本的应用场景,基本上是无需引入这种缓存框架的,因为客户端的并发量很少,而且数据请求也是寥寥可数的,性能方便不会有任何问题。

如果对于分布式的应用系统,如我在很多随笔中介绍到我的《混合式开发框架》、《Web开发框架》,由于数据请求是并发量随着用户增长而增长的,特别对于一些互联网的应用系统,极端情况下某个时间点一下可能就会达到了整个应用并发的峰值。那么这种分布式的系统架构,引入数据缓存来降低IO的并发数,把耗时请求转换为内存的高速请求,可以极大程度的降低系统宕机的风险。

我们以基于常规的Web API层来构建应用框架为例,整个数据缓存层,应该是在Web
API层之下、业务实现层之上的一个层,如下所示。

澳门微尼斯人手机版 3

在这个数据缓存层里面,我们引入了CacheManager缓存框架,实现分布式的缓存处理,使得我们的缓存数据能够在Redis服务器上实现数据的处理,同时可以在系统重启的时候,不至于丢失数据,能够快速恢复缓存数据。

为了实现对这个CacheManager缓存框架的使用,我们需要先进行一个使用测试,以便了解它的各个方便情况,然后才能广泛应用在我们的数据中间层上。

我们建立一个项目,并在引用的地方打开管理NuGet程序包,然后搜索到CacheManager的相关模块应用,并加入到项目引用里面,此为第一步工作。

澳门微尼斯人手机版 4

澳门微尼斯人手机版 5

我们创建一个客户对象类,用来模拟数据的存储和显示的,如下代码所示。

/// <summary>
/// 模拟数据存储的客户对象类
/// </summary>
public class Customer
{
    private static Customer m_Customer = null;
    private static ICacheManager<object> manager = null;

    //初始化列表值
    private static List<string> list = new List<string>() { "123", "456", "789" };

    /// <summary>
    /// 客户对象的单件实例
    /// </summary>
    public static Customer Instance
    {
        get
        {
            if(m_Customer == null)
            {
                m_Customer = new Customer();
            }
            if (manager == null)
            {
                manager = CacheFactory.Build("getStartedCache", settings =>
                {
                    settings.WithSystemRuntimeCacheHandle("handleName");
                }); 
            }

            return m_Customer;
        }
    }

这个类先做了一个单例的实现,并初始化缓存Customer类对象,以及缓存管理类ICacheManager<object>
manager,这个是我们后面用来操作缓存数据的主要引用对象。

我们编写几个函数,用来实现对数据的获取,数据增加、数据删除的相关操作,并在数据增加、删除的时候,触发缓存的更新,这样我们下次获取数据的时候,就是最新的数据了。

/// <summary>
/// 获取所有客户信息
/// </summary>
/// <returns></returns>
public List<string> GetAll()
{
    var value = manager.Get("GetAll") as List<string>;
    if(value == null)
    {
        value = list;//初始化并加入缓存
        manager.Add("GetAll", value);

        Debug.WriteLine("初始化并加入列表");
    }
    else
    {
        Debug.WriteLine("访问缓存获取:{0}", DateTime.Now);
    }
    return value;
}

/// <summary>
/// 插入新的记录
/// </summary>
/// <param name="customer"></param>
/// <returns></returns>
public bool Insert(string customer)
{
    //先获取全部记录,然后加入记录
    if (!list.Contains(customer))
    {
        list.Add(customer);
    }

    //重新设置缓存
    manager.Update("GetAll", v => list);
    return true;
}

/// <summary>
/// 删除指定记录
/// </summary>
/// <param name="customer"></param>
/// <returns></returns>
public bool Delete(string customer)
{
    if(list.Contains(customer))
    {
        list.Remove(customer);
    }
    manager.Update("GetAll", v=>list);
    return true;
}

我们编写一个Winform程序来对这个缓存测试,以方便了解其中的机制。

澳门微尼斯人手机版 6

我们在测试读取的时候,也就是对GetAll进行处理,插入以及删除主要就是为了测试缓存更新的处理。代码如下所示。

private void btnTestSimple_Click(object sender, EventArgs e)
{
    var list = Customer.Instance.GetAll();
    Debug.WriteLine("客户端获取记录数:{0}", list != null ? list.Count : 0);
}

private void btnInsert_Click(object sender, EventArgs e)
{
    var name = "abc";
    Customer.Instance.Insert(name);
    Debug.WriteLine(string.Format("插入记录:{0}", name));
}

private void btnDelete_Click(object sender, EventArgs e)
{
    var name = "abc";
    Customer.Instance.Delete(name);
    Debug.WriteLine(string.Format("删除记录:{0}", name));
}

我们跟踪记录,可以看到下面的日志信息。

澳门微尼斯人手机版 7

我们可以看到,其中第一次是缓存没有的情况下进行初始化,初始化的记录数量为3个,然后插入记录后,再次获取数据的时候,缓存更新后的数量就变为4个了。

我们前面介绍了插入记录的后台代码,它同时进行了缓存数据的更新了。

/// <summary>
/// 插入新的记录
/// </summary>
/// <param name="customer"></param>
/// <returns></returns>
public bool Insert(string customer)
{
    //先获取全部记录,然后加入记录
    if (!list.Contains(customer))
    {
        list.Add(customer);
    }

    //重新设置缓存
    manager.Update("GetAll", v => list);
    return true;
}

我们前面介绍的缓存初始化配置的时候,默认是使用内存缓存的,并没有使用分布式缓存的配置,它的初始化代码如下:

manager = CacheFactory.Build("getStartedCache", settings =>
{
    settings.WithSystemRuntimeCacheHandle("handleName");
}); 

我们在正常情况下,还是需要使用这个强大的分布式缓存的,例如我们可以使用Redis的缓存处理,关于Redis的安装和使用,请参考我的随笔《基于C#的MongoDB数据库开发应用(4)–Redis的安装及使用》。

引入分布式的Redis缓存实现,我们的配置代码只需要做一定的改变即可,如下所示。

manager = CacheFactory.Build("getStartedCache", settings =>
{
    settings.WithSystemRuntimeCacheHandle("handleName")

    .And
    .WithRedisConfiguration("redis", config =>
    {
        config.WithAllowAdmin()
            .WithDatabase(0)
            .WithEndpoint("localhost", 6379);
    })
    .WithMaxRetries(100)
    .WithRetryTimeout(50)
    .WithRedisBackplane("redis")
    .WithRedisCacheHandle("redis", true)
    ;
}); 

其他的使用没有任何变化,我们同时增加一些测试数据方便我们查阅对应的缓存数据。

/// <summary>
/// 测试加入几个不同的数据
/// </summary>
/// <returns></returns>
public void TestCache()
{
    manager.Put("string", "abcdefg");
    manager.Put("int", 2016);
    manager.Put("decimal", 2016.9M);
    manager.Put("date", DateTime.Now);
    manager.Put("object", new UserInfo { ID = "123", Name = "Test", Age = 35 });
}

private void btnTestSimple_Click(object sender, EventArgs e)
{
    var list = Customer.Instance.GetAll();
    Debug.WriteLine("客户端获取记录数:{0}", list != null ? list.Count : 0);

    //测试加入一些值
    Customer.Instance.TestCache();
}

我们其中测试,一切和原来没有什么差异,程序的记录信息正常。

但是我们配置使用了Redis的缓存处理,因此可以使用“Redis Desktop
Manager”软件来查看对应的缓存数据的,打开软件我们可以看到对应的缓存记录如下所示。

澳门微尼斯人手机版 8

从上图我们可以查看到,我们添加的所有缓存键值都可以通过这个Redis的客户来进行查看,因为我们缓存里面有基于Redis缓存的实现,同理如果我们配置其他的缓存实现,如MemCache等,那么也可以在对应的管理界面上查看到。

我们完成这些处理后,可以发现缓存数据是可以实现多层缓存的,最为高效的就是内存缓存(也是它的主缓存),它会自动协同好各个分布式缓存的数据版本冲突问题。

引入如Redis的分布式缓存有一个好处,就是我们的数据可以在程序重新启动的时候,如果没有在内存缓存里面找到(没有击中目标),那么会寻找分布式缓存并进行加载,从而即使程序重启,我们之前的缓存数据依旧保存完好。

 

以上就是我基于对缓存框架的整体了解和其角色扮演做的相关介绍,以及介绍CacheManager的使用和一些场景的说明,通过上面简单案例的研究,我们可以逐步引入到更具实际价值的Web
API
框架层面上进行使用,以期把缓存框架发挥其真正强大的价值,同时也为我们各种不同的缓存需要进行更高层次的探索,希望大家继续支持。

 

 

本文参照资料

1.1989年的圣诞节期间,吉多*范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的解释程序,作为ABC语言的一种继承。

   GNU make  
–    

 

   跟我一起写Makefile 

 

   入门基础Makefile概述 
– 

 

推荐需要简单看看上面资料. 特别是第三个入门教程, 了解基础make语法. 
看完后那我们扩展之路开始了, 先hello world 讲起. 素材 mian.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

#define ALEN(arr) (sizeof(arr)/sizeof(*arr))

/*
 * 简单的demo测试
 */
int main(int argc, char * argv[]) {
    int i;
    const char * strs[] = {
        "走着走着,就散了,回忆都淡了",
        "看着看着,就累了,星光也暗了;",
        "听着听着,就醒了,开始埋怨了;",
        "回头发现,你不见了,突然我乱了。",
    };

    srand((unsigned)time(NULL));
    for(;;) {
        /*
         *    \e[ 或 \033[ 是 CSI,用来操作屏幕的。
         *    \e[K 表示从光标当前位置起删除到 EOL (行尾)
         *    \e[NX 表示将光标往X方向移动N,X = A(上) / B(下) / C(左) / D(右),\e[1A 就是把光标向上移动1行
         */
        printf("\033[1A\033[K"); //先回到上一行, 然后清除这一行  

        // 随机输出一段话
        i = rand()%ALEN(strs);
        puts(strs[i]);

        sleep(3);
    }    

    return 0;
}

编译上面程序的第一个Makefile 文件内容如下

main.out:main.c
    gcc -g -Wall -o $@ $^

执行过程就是通过shell执行make, 我们简单翻译一下上面写法的含义.

  目标 main.out  依赖 main.c ;  main.c 已经存在(因为是存在的文件)
那就执行规则 (gcc -g -Wall -o $@ $^).

  其中 $@ 表示所有目标, $^表示所有依赖. 

是不是很简单.当然上面Makefile还存在一些潜规则.

  所有执行规则都是以\t开始; 第一个目标就是make过程唯一执行的起点;

 

再讲之前我们再扯一点gcc 相关的积累知识. 否则写Makefile都是无米之炊. 

# 中间插入一段关于gcc 的前戏
gcc –E –o main.i mian.c    # -E是预处理展开宏,生成详细c文件, -o是输出
gcc –S –o main.s main.i    # -S 是编译阶段, 将c文件生成汇编语言
gcc –c –o main.o main.s    # -c 是汇编阶段, 生成机器码
gcc –o main.exe main.o     # 链接阶段, -o 生成目标执行程序

gcc –g      # 编译中加入调试信息, 方便gdb调试, 还有-ggdb3 支持宏调试等
gcc –Wall    # 输出所有警告信息
gcc –O2        # 开启调优, O2等级调优

gcc –I(i大写)            # 导入头文件目录,方便 *.h文件查找
gcc –L(l 大写)          # 导入库文件目录,方便 *.so和*.a文件查找
gcc –l(l 小写)           # 导入库文件, 例如-lpthread, 相当于依次查找导入 libpthread.so/libpthread.a 文件
gcc –static –l(l 小写)   # 指定只查找 静态库 lib*.a 文件, linux约定库文件都是 lib开头


ar rc libheoo.a hello.o world.o                    # 将*.o 文件打包成 libheoo.a 静态库
gcc –fPIC –shared –o libheoo.so hello.o world.o    # 将*.o 文件打包成 libheoo.so 动态库

到这里储备方面的讲完毕了.   –<-<-<@

 

前言  –  介绍一下实际例子中语法套路

   首先升级一下上面Makefile文件, 如下(如果你复制没法执行,
请检查规则开头字符是\t)

# 构建全局编译操作宏
CC = gcc 
CFLAGS = -g -Wall -O2 
RUNE = $(CC) $(CFLAGS) -o $@ $^
RUNO = $(CC) -o $@ $<

# 构建伪命令
.PHONY:all clean cleanall

# 第一个标签, 是make的开始
all:main.out

main.out:main.c
    $(RUNE)

# 清除操作
clean:
    -rm -rf *.i *.s *.o *~
cleanall:clean
   -rm -rf *.out *.out *.a *.so

我们先说一下Makefile中变量的使用, 就是上面 “=”那种基础语法说明.

 

关于Makefile 变量总结如下

关于上面变量的使用这里做一个总结. 

a. = 声明变量
加入存在下面场景
…
CC = cc
…
CC = gcc

那么make的时候, $(CC) 就是 gcc, 会全局替换. 
对于 = 声明的可以认为是一个全局递归替换宏. 

b. := 声明变量

… 
srcdir := ./coroutine
tardir := ./Debug
… 
上面就是一般语言中普通变量. 

c. ?= 声明变量

Foo ?= bar

上面意思是 $(foo)不存在, 那就将 bar 给它. 等同于
ifeq ($(origin FOO), undefined)
  FOO = bar
endif

d. += 声明变量

objects = main.o foo.o bar.o utils.o
objects += another.o
等同于

objects = main.o foo.o bar.o utils.o
objects := $(objects) another.o

趁着热度举个例子, 先不解惑. 

CC = cc
FOO := foo 
BAR ?= bar 
HEO := heo 

all :
    echo $(CC)
    echo $(FOO)
    echo $(BAR)
    echo $(HEO) 

HEO += world
FOO := FOO 
CC = gcc 

执行结果如下, 如下图 . 通过Demo外加上下面运行结果图, 应该会有收获.

澳门微尼斯人手机版 9

通过上面我们可以发现 := 和 = 声明的变量都是最终全局替换之后的结果.
他们二者细微差别, 我还是通过例子来说吧.

澳门微尼斯人手机版 10

一切都在不言中, 那么关于Makefile变量中语法讲解完毕. 顺带说一些小细节吧,

  1). Makefile 中 一切从简单开始, 能用 = 就不要用 :=

  2). 变量具备全部作用域 , 推荐全部用大写命名

  3). 多查最开始我推荐的资料

 

接着变量往后讲,继续分析其它例子

上面 .PHONY 是 Makefile中伪命令. 默认套路写法. 定义命令名称, 可以通过
make 命令名称调用.

其中 all 是Makefile第一个运行目标,  从它入口. clean , cleanall 伪命令
通过 make clean ; make cleanall 执行.

主要是清除生成的中间文件. 希望你能明白, 自己演示一下, 是不是这样的.

这里我们开始一个新的例子了. 具体参照

 
C协程库的编译文件 

# 全局替换变量
CC = gcc 
CFLAGS = -g -Wall -O2 
RUNE = $(CC) $(CFLAGS) -o $@ $^

# 声明路径变量
SRC_PATH := ./coroutine
TAR_PATH := ./Debug

# 构建伪命令
.PHONY:all clean cleanall

# 第一个标签, 是make的开始
all:$(TAR_PATH)/main.out

$(TAR_PATH)/main.out:main.o scoroutine.o
    $(CC) $(CFLAGS) -o $@ $(addprefix $(TAR_PATH)/, $^ )

$(TAR_PATH):
    mkdir $@

%.o:$(SRC_PATH)/%.c | $(TAR_PATH)
    $(CC) $(CFLAGS) -c -o $(TAR_PATH)/$@ $<

# 清除操作
clean:
  -rm -rf $(TAR_PATH)/*.i $(TAR_PATH)/*.s $(TAR_PATH)/*.o $(TAR_PATH)/*~
cleanall:clean
  -rm -rf $(TAR_PATH)

从头开始分析它的具体含义.

1) 开头全局变量定义部分, 个人习惯问题其实也可以用 := . 最终得到 RUNE =
gcc -g -Wall -O2 -o $@ $^ .

2) 路径声明部分, 用 := 声明, 支持中间拼接. 用=也可以,
都是条条大路同罗马, 自己多检查一下. 以后我可能全部用 =
声明全局递归的字面变量声明. 

3) .PHONY 声明了 3个伪命令. 不会立即执行的命令, 依赖 make 命令名称
主动调用

4) all 依赖 于 $(TAR_PATH)/main.out 就是依赖于 ./coroutine/main.out. 刚好下面存在

$(TAR_PATH)/main.out:main.o scoroutine.o
    $(CC) $(CFLAGS) -o $@ $(addprefix $(TAR_PATH)/, $^ ) 

这条规则. 其中又依赖于 main.o 和 scoroutine.o 目标.
那么二者也会做新的目标, 就这样递归的找下去.
后面找到了 %.o, Makefile中%是匹配符, 例如
main.o % 就相当于 main部分.
其中addprefix 是GNU
make内置的函数的其中一个, 需要用到的时候多查文档就行了.

为每一个可以分割的子单元上加上一个前缀,
这个前缀就是它的第一个参数.

5) 对于下面这段很实用, 通配符 + | 生成必要文件的语法

%.o:$(SRC_PATH)/%.c | $(TAR_PATH)
    $(CC) $(CFLAGS) -c -o $(TAR_PATH)/$@ $<

以上是一个通用匹配规则, %.o 目标依赖于 …./%.c 具体文件. 后面 |
跟的也是一个依赖目标. 这个目标只会在第一次不存在的时候才会被构建.

更加详细的说明可以参照第一个参照资料 “4.3 Types of Prerequisites” 部分. 
这个语法用的很多, 用于构建一次生成所需的目录信息.

6) 最后就是剩余clean, cleanall伪命令. 定义清除中间文件等.

是不是想骂die, 但是上面那些都自行捣鼓了一遍, 基本就越过Makefile初级部分,
能够写出能看的编译文件O(∩_∩)O哈哈~

 

正文  – 来个小框架Makefile试试水

  先找一个特别老的, 很水的一个Makefile 试试. 具体参照

  一个控制台小项目编译文件  

C = gcc
DEBUG = -g -Wall -D_DEBUG
#指定pthread线程库
LIB = -lpthread -lm
#指定一些目录
DIR = -I./module/schead/include -I./module/struct/include
#具体运行函数
RUN = $(CC) $(DEBUG) -o $@ $^ $(LIB) $(DIR)
RUNO = $(CC) $(DEBUG) -c -o $@ $^ $(DIR)

# 主要生成的产品
all:test_cjson_write.out test_csjon.out test_csv.out test_json_read.out test_log.out\
 test_scconf.out test_tstring.out

#挨个生产的产品
test_cjson_write.out:test_cjson_write.o schead.o sclog.o tstring.o cjson.o
    $(RUN)
test_csjon.out:test_csjon.o schead.o sclog.o tstring.o cjson.o
    $(RUN)
test_csv.out:test_csv.o schead.o sclog.o sccsv.o tstring.o
    $(RUN)
test_json_read.out:test_json_read.o schead.o sclog.o sccsv.o tstring.o cjson.o
    $(RUN)
test_log.out:test_log.o schead.o sclog.o
    $(RUN)
test_scconf.out:test_scconf.o schead.o scconf.o tree.o tstring.o sclog.o
    $(RUN)
test_tstring.out:test_tstring.o tstring.o sclog.o schead.o
    $(RUN)

#产品主要的待链接文件
test_cjson_write.o:./main/test_cjson_write.c
    $(RUNO)
test_csjon.o:./main/test_csjon.c
    $(RUNO)
test_csv.o:./main/test_csv.c
    $(RUNO)
test_json_read.o:./main/test_json_read.c
    $(RUNO)
test_log.o:./main/test_log.c 
    $(RUNO) -std=c99
test_scconf.o:./main/test_scconf.c
    $(RUNO)
test_tstring.o:./main/test_tstring.c
    $(RUNO)

#工具集机械码,待别人链接
schead.o:./module/schead/schead.c
    $(RUNO)
sclog.o:./module/schead/sclog.c
    $(RUNO)
sccsv.o:./module/schead/sccsv.c
    $(RUNO)
tstring.o:./module/struct/tstring.c
    $(RUNO)
cjson.o:./module/schead/cjson.c
    $(RUNO)
scconf.o:./module/schead/scconf.c
    $(RUNO)
tree.o:./module/struct/tree.c
    $(RUNO)

#删除命令
clean:
    rm -rf *.i *.s *.o *.out __* log ; ls -hl
.PHONY:clean

上面那些注释已经表达了一切了吧, 确实好水. 但是特别适合练手,
每一个生成目标都有规则对应. 费力但是最直接. 实在没有没有好讲的, 扯一点

1) GNU make 指定的编译文件是 makefile 或 Makefile. 推荐用Makefile,
是一个传统吧. 因为C项目都是小写, 用大写开头以作区分.

2) Makefile 中 同样以 \ 来起到一整行的效果

3) 其它目标, 依赖, 规则.只要存在那么Makefile就可以自动推导.
当然它依赖文件创建时间戳, 只有它变化了Makefile才会重新生成目标.

Makefile点心结束了. 以上就是make使用本质, 生成什么, 需要什么, 执行什么.
推荐练练手, 手冷写不了代码.

 

最后来点水果

  simplec
c的简易级别框架 

##################################################################################################
#                            0.前期编译辅助参数支持                                                 #
##################################################################################################
SRC_PATH         ?= ./simplec
MAIN_DIR         ?= main
SCHEAD_DIR       ?= module/schead
SERVICE_DIR      ?= module/service
STRUCT_DIR       ?= module/struct
TEST_DIR         ?= test
TAR_PATH         ?= ./Output
BUILD_DIR        ?= obj

# 指定一些目录
DIR     =    -I$(SRC_PATH)/$(SCHEAD_DIR)/include -I$(SRC_PATH)/$(SERVICE_DIR)/include \
            -I$(SRC_PATH)/$(STRUCT_DIR)/include

# 全局替换变量
CC        = gcc 
LIB       = -lpthread -lm
CFLAGS    = -g -Wall -O2 -std=gnu99

# 运行指令信息
define NOW_RUNO
$(notdir $(basename $(1))).o : $(1) | $$(TAR_PATH)
    $$(CC) $$(CFLAGS) $$(DIR) -c -o $$(TAR_PATH)/$$(BUILD_DIR)/$$@ $$<
endef

# 单元测试使用, 生成指定主函数的运行程序
RUN_TEST = $(CC) $(CFLAGS) $(DIR) --entry=$(basename $@) -nostartfiles -o \
    $(TAR_PATH)/$(TEST_DIR)/$@ $(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v))

# 产生具体的单元测试程序
define TEST_RUN
$(1) : $$(notdir $$(basename $(1))).o libschead.a $(2) | $$(TAR_PATH)
    $$(RUN_TEST) $(LIB)
endef

##################################################################################################
#                            1.具体的产品生产                                                      #
##################################################################################################
.PHONY:all clean cleanall

all : main.out\
    $(foreach v, $(wildcard $(SRC_PATH)/$(TEST_DIR)/*.c), $(notdir $(basename $(v))).out)

# 主运行程序main
main.out:main.o simplec.o libschead.a libstruct.a test_sctimeutil.o
    $(CC) $(CFLAGS) $(DIR) -o $(TAR_PATH)/$@ $(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v)) $(LIB)

# !!!!! - 生成具体的单元测试程序 - 依赖个人维护 - !!!!!
$(eval $(call TEST_RUN, test_array.out, array.o))
$(eval $(call TEST_RUN, test_atom_rwlock.out))
$(eval $(call TEST_RUN, test_cjson.out, tstr.o))
$(eval $(call TEST_RUN, test_cjson_write.out, tstr.o))
$(eval $(call TEST_RUN, test_csv.out, tstr.o))
$(eval $(call TEST_RUN, test_json_read.out, tstr.o))
$(eval $(call TEST_RUN, test_log.out))
$(eval $(call TEST_RUN, test_scconf.out, tstr.o tree.o))
$(eval $(call TEST_RUN, test_scoroutine.out, scoroutine.o))
$(eval $(call TEST_RUN, test_scpthread.out, scpthread.o scalloc.o))
$(eval $(call TEST_RUN, test_sctimer.out, sctimer.o scalloc.o))
$(eval $(call TEST_RUN, test_sctimeutil.out))
$(eval $(call TEST_RUN, test_tstring.out, tstr.o))
$(eval $(call TEST_RUN, test_xlsmtojson.out, tstr.o))

##################################################################################################
#                            2.先产生所需要的所有机器码文件                                          #
##################################################################################################

# 循环产生 - 所有 - 链接文件 *.o
SRC_CS = $(wildcard\
    $(SRC_PATH)/$(MAIN_DIR)/*.c\
    $(SRC_PATH)/$(TEST_DIR)/*.c\
    $(SRC_PATH)/$(SCHEAD_DIR)/*.c\
    $(SRC_PATH)/$(SERVICE_DIR)/*.c\
    $(SRC_PATH)/$(STRUCT_DIR)/*.c\
)
$(foreach v, $(SRC_CS), $(eval $(call NOW_RUNO, $(v))))

# 生产 -相关- 静态库
libschead.a : $(foreach v, $(wildcard $(SRC_PATH)/$(SCHEAD_DIR)/*.c), $(notdir $(basename $(v))).o)
    ar cr $(TAR_PATH)/$(BUILD_DIR)/$@ $(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v))
libstruct.a : $(foreach v, $(wildcard $(SRC_PATH)/$(STRUCT_DIR)/*.c), $(notdir $(basename $(v))).o)
    ar cr $(TAR_PATH)/$(BUILD_DIR)/$@ $(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v))

##################################################################################################
#                            3.程序的收尾工作,清除,目录构建                                          #
##################################################################################################
$(TAR_PATH):
    -mkdir -p $@/$(BUILD_DIR)
    -mkdir -p $@/test/config
    -cp -r $(SRC_PATH)/test/config $@/test

# 清除操作
clean :
    -rm -rf $(TAR_PATH)/$(BUILD_DIR)/*

cleanall :
    -rm -rf $(TAR_PATH)

 

具体可以参照simplec 项目查看, 我们抽一部分重点讲解

define NOW_RUNO
$(notdir $(basename $(1))).o : $(1) | $$(TAR_PATH)
    $$(CC) $$(CFLAGS) $$(DIR) -c -o $$(TAR_PATH)/$$(BUILD_DIR)/$$@ $$<
endef

上面定义了一个语句块 NOW_RUNO. 其中语句块中除了要接收的参数可以用$(1),
$(2) …, 其它都是两个$$开头, 否则就被替换了. 使用方法就是

$(eval $(call NOW_RUNO, $(v)))

通过$eval(), $(call ) 这种套路调用. call NOW_RUNO, 后面添加都是
NOW_RUNO语句块的函数了.

这里说一个Makefile处理的潜在小问题, 当你传入参数是依赖项时候,
如果不是直接通过唯一一个参数传入进去,

那么解析的是当成多个依赖项处理.所以上面只有 $(1)做依赖项.

Makefile中 foreach语法也很好用等同于shell语法传参方式.

$(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v))
将第二个$^通过空格分隔成单个的v代替, 被替换为第三个中一部分. $(foreach ...)执行完毕最终返回一个拼接好的串

 

在简单补充几个函数说明 例如

$(1) => $$(notdir $$(basename $(1))).o <=> ./simplec/main/main.c => main.o

其中 nodir函数得到文件名, basename函数得到文件名不包过.和.后面部分.
wildcard 函数是得到指定匹配规则下的文件全路径拼接.
最后面 -rm 那些, 加了前缀 – 是为了当Makefile执行到这如果运行出错,
不停止继续前行.
通过上面Makefile最终跑起来后, 会生成一个Output目录, 再在内部生成 obj,
test, …
还是很有学习价值的. 有兴趣的可以试试.
希望通过上面讲解, 能够使你以后阅读其它更高级项目的编译文件不那么生疏.
(* ̄(エ) ̄)

 

后记  –  突然想起了什么, 笑了笑 我自己 …

  伽罗  –
 

澳门微尼斯人手机版 11

 

2.ABC是由吉多参加设计的一种教学语言,就吉多本人看来,ABC这种语言非常优美和强大,是专门为非专业程序员设计的。但是ABC语言并没有成功,

究其原因,吉多认为是非开发造成的。吉多决心在Python中避免这一错误,并获取了非常好的效果。

 

3.之所以选中Python(蟒蛇)作为程序的名字,是因为他是BBC电视剧–蒙提*派森的飞行马戏团(Monty Python’s Flying Circus)的爱好者。

 

4.1991年,第一个Python解释器诞生,它是用C语言实现的,并能够调用C语言的库文件。

 

 

1.Python的设计目标

 

1999年,吉多*范罗苏姆向DARPA提交了一条名为”Computer Programming For
Everybody”的资金申请,并在后来说明了他对Python的目标:

 

  1.一门简单直观的语言并与主要竞争者一样强大

  2.开源,以便任何人都可以为它做贡献   

  3.代码像纯英语那样容易理解

  4.适用于短期开发的日常任务

 

 

这些想法中的基本都已经成为现实,Python已经成为一门流行的编程语言

 

 

澳门微尼斯人手机版, 

2.Python的设计哲学

 

 澳门微尼斯人手机版 12

 

  1. Python开发者的哲学是:用一种方法,最好是只有一种方法来做一件事

2.如果面临多种选择,Python开发者一般会拒绝花俏的语法,而选择明确没有或很少有歧义的语法

 

在Python社区,吉多被称为“仁慈的独裁者” 

 

 

 

3.为什么使用Python

 

同一样问题,用不同的语言解决,代码量差距还是很多的,一般情况下Python是Java的1/5,所以说人生苦短,我用Python。

发表评论

电子邮件地址不会被公开。 必填项已用*标注