伏尔塔瓦河

https://music.163.com/song?id=1112818

斯美塔纳交响诗套曲《我的祖国》的第二乐章。斯美塔纳这样形容他心目中捷克的母亲河：

伏尔塔瓦河有两个源头——流过寒风呼啸的森林的两条溪水汇合成一道洪流，冲着鹅卵石哗哗作响，映着阳光闪烁光芒。它在森林中梭巡，聆听猎号的回音；他穿过庄稼地，饱览丰盛的收获。在它的两岸，传出乡村婚礼的欢乐声，月光下，水仙女唱着迷人的歌在浪尖上嬉戏。在近旁荒野的悬崖上，保留着昔日光荣和功勋记忆的那些城堡废墟，谛听着它的波浪喧哗。顺着圣约翰峡谷，伏尔塔瓦河奔泻而下，冲击着突岩峭壁，发出轰然巨响。尔后，河水更广阔地奔向布拉格，流经古老的维谢格拉得，现出它全部的瑰丽和庄严。伏尔塔瓦河继续滚滚向前，最后同易北河的巨流汇合并逐渐消失在远方。

以下内容选自《穿T恤听古典音乐》

一开始，单簧管和长笛奏出潺潺溪流，像森林中的伏尔塔瓦河源头。音乐是如何模仿的？何以如此逼真？它们的活泼速度模仿溪流的节奏，上下起伏的浅浅小旋律模仿水流的曲线。这两条小溪流逐渐汇成小河，河流依旧轻快向前，逐渐地，小河铺展成了一段伴奏，欣然等待一支音乐主题。

这首主题在弦乐队唱起的时候，人们恍然一笑，啊，原来就是这首啊。时常在广告、片头和电影里听见。这个曲调就是《伏尔塔瓦河》的主题。旋律如波浪，水波自波谷蓄积，升起，再渐渐褪去，一波一波，平缓而开阔，一幅大河的画卷在音乐中展开。旋律中还可听见一条河流的气度和描绘它的人满怀自豪感。它的平缓中激情不息，就像人们初见这条美丽的大河时心中流淌的赞叹，同时它又保留着沿岸的波希米亚风格。同一条旋律可以被多层面解读，可见这模仿哪里容易！斯美塔纳对这条大河的感情深沉无言，音乐的表白超越了任何言语。

……

紧接着，河流转弯了，这时波浪仿佛消失。一个轻快的波尔卡舞曲节奏从远处传来。这是流经哪里了，波希米亚小村庄，还是一场舞会、一场乡村婚礼？弦乐器演奏淳朴温暖的乡间民谣，节奏里似乎回荡着啤酒和布拉格香肠的朴实香味。

……

伏尔塔瓦河继续流淌。再后来，音色变了，温暖的音色转变成冷色调，背景处，弦乐的泛音晶莹，如洒在河面的银色月光。清冽的木管音色，大管、双簧管和单簧管次第铺展。顿时天色变了，曲调放缓，河流流向夜里。这月光下的河流并非类似肖邦的清丽或舒曼的幻觉，竟带着几分天真的民间神话气息。晶莹的竖琴声从水中一颗颗升起，神话的情节如银粉散开，变出几百个洁白的水仙女。听到这里，想起德沃夏克（Antonín Leopold Dvořák）有一部著名的歌剧《水仙女》，这是在捷克家喻户晓的童话。

在长笛的呼啸声里，定音鼓声在河流底部滚动，长号齐鸣，河流变得湍急，回到了最初溪流汇入大河的景象，但更澎湃激越，此时弦乐队唱起熟悉的甘美主题，宛如一股暖流。即使对一条河流的简单模仿，也拥有了抚慰人心的力量。之后乐队持续不息，铜管齐鸣，一层层沸腾，乐器、节奏、旋律，每一个漩涡都变得明快，铜管乐器带来了金色的庄严感，此时你发现河流越来越壮阔，一定是流到首都布拉格了。

网上能搜到的《伏尔塔瓦河》演奏，大多是卡拉扬指挥柏林爱乐乐团的演奏版本，堪称这一曲目的典范演绎，结构缜密，气势夺人，所有细节都一丝不苟。为这样一支名曲，树立一种无偏颇的典范演绎十分必要。而我更怀念的是1990年“布拉格之春”音乐节的那场演出，担任指挥的是捷克指挥家库贝利克（Rafael Jeroným Kubelík）。库贝利克录过6次斯美塔纳的《我的祖国》，是捷克音乐诠释的权威人物，而他的指挥倒没有卡拉扬那么“权威”，他更随和质朴一些，讲母语总是舒服的，我们听来也更舒服。那时库贝利克76岁，离开了捷克42年，第一次回国演出，也是他第二次登上“布拉格之春”这个隆重的音乐节。即使他一直旅居瑞士和美国，去世之后，仍是在捷克入葬，让灵魂与躯体融入家乡的河流与土地。音乐家的故事和乐曲交织在一起，有了悲欢离合，有了人的悲悯，音乐才有了灵魂。

《伏尔塔瓦河》不只模仿了一条河流的故事，它在模仿的过程中已经自然浇灌出了乐曲的结构。音乐的结构与文学不太一样。文学有故事，有具体情节，音乐可以模仿人物事件，但至多是暗示，并不确定，听者的想象以主观成分居多。音乐有它自己的逻辑，这逻辑遵循人的听觉记忆的自然原理。音乐主题若是一闪而过，人们会记不住，也不过瘾，于是主题要重复，但重复太多人们又会腻烦，所以作曲家会变化重复，比如转调，变化和声、音色、节奏。而在一定的重复之后，需要一个对比段落，让听者振奋情绪，并塑造音乐中的矛盾冲突，于是相应而生音乐性格对比的段落，在经历了一系列的变化与发展之后，再来一个最终的主题再现，以各种动力的、激情的方式重申主题，类似文学作品最后的大结局。在古典主义时代之前，最后的再现段落往往照搬呈示部，不予变化，后来为了更饱满更动人的情感表达，再现部往往更有动力，规模庞大，飞流直下浩浩汤汤，直到乐曲结束。

《伏尔塔瓦河》的第一段，是河流生长与成型的呈示段；接着河流经过小村庄，就有了节奏与情节对比的波尔卡舞曲段落；第三段仍是对比，变的是音色，并将音乐的内在节拍放慢，展示音乐情绪与音色的对比；第四段是再现，乐队全奏，辉煌收尾。如此结构，既是一条河流的描述，也遵循呈示、对比（展开）、再现的三明治式音乐结构原则。

莫斯科河上的黎明

https://music.163.com/song?id=1351564275

该曲为穆索尔斯基的歌剧《霍万兴那》的前奏曲，是一首富有诗意的前奏曲，可脱离歌剧的内容去欣赏。以下赏析内容可忽略：

乐曲描绘当年莫斯科的清晨景色，矮小的木头房子，散置耸起的贵族府邸的尖屋顶和教堂的镀金圆顶，还有在朦胧的晨曦中隐约可辨认出轮廓的克里姆林宫和教堂，天空刚现出朝霞，朝阳的光芒让高高突起的尖的和圆的屋顶镶上了一道金边，耀眼的太阳终于升起……

乐曲开始，中提琴和长笛奏出来自基本主题的引子，在寂静中像袅袅上升的朝霞，逐渐转入高音区，由第二小提琴和单簧管覆奏，结合着此起彼落仿似是公鸡的啼叫声，营造出晨曦景象。随后是乐曲的基本主题和四次变奏。基本主题源出于抒缓的俄罗斯抒情歌曲旋律，宽广、明亮、和谐而真挚。

这个基本主题分别在不同的乐器出现，调性不断更换，每次变奏音响都更饱满、更明亮。夜巡归来的士兵的步履声，教堂清晨的钟声等，将音响力度逐渐加强，将音乐的色调增浓，生动地描画出从黎明前的阴晦，转变为清朗的白昼景象。乐曲结尾再次减弱，但色彩更明朗清澈;最后长笛和单簧管交替，模仿牧笛的呼应，最后在慢慢消逝的柔美圆号声中结束。

(周凡夫)

蓝色多瑙河

https://music.163.com/song?id=5276811

小约翰·斯特劳斯的经典圆舞曲，按照典型的维也纳圆舞曲的结构写成，由序奏、五个小圆舞曲和尾声组成：

序奏开始时，小提琴在 A 大调上用碎弓轻轻奏出徐缓的震音，好似黎明的曙光拨开河面上的薄雾，唤醒了沉睡大地，多瑙河的水波在轻柔地翻动。接下来是五首连着一起演奏的小圆舞曲，每首小圆舞曲都包含两个相互对比的主题旋律。整首乐曲优美典雅、欢快迷人。

你喜欢星巴克吗？你会去寻找好喝的、十几二十块钱一杯的、可能排队半小时的 XX 茶吗？
你热衷于 K-POP 文化吗？你会在微博上为自己的粉丝刷赞刷转发，给自己的偶像撑场子吗？
你喜欢电音吗？你会去音乐节感受人的海洋吗？你网易云音乐有十级吗？你对耳机有所追求吗？
你喜欢看电影吗？你会一个人去看电影吗？你更喜欢 DC 还是漫威？你觉得伏地魔和格林德沃谁更强？
……

或者，以上这些你喜欢的不多，你只是个普通的、没什么空余时间的上班族。
你或许搭乘交通工具，在城市中穿梭往来，每天上班、下班，在人流中穿梭，每天只是看自己的手机、吃自己的饭、听自己的歌。

……

想到还在清水河的时候，不下十次一个人跑去电影院，看感兴趣的片子，不由自主地笑了。

评论里有人推荐谢尔的《失落的一角》，原来是简单的绘本。作者用寥寥几语和简洁线条，叙述了一个耐人寻味的寓言。

礼物

如此幸福的一天
雾早就散了
我在花园里干活
蜂鸟停在忍冬花上

这世上没有一样东西我想占有
我知道没有一个人值得我羡慕

任何我曾遭遇的不幸
我都已忘记

想到故我今我同为一人并不使我难为情
在我身上没有痛苦

直起身来
我望见蓝色的大海和帆影

窗

黎明时我向窗外了望
见棵年轻的苹果树沐着曙光

又一个黎明我望着窗外
苹果树已经是果实累累

可能过去了许多岁月
睡梦里出现过什么，我再也记不起

可怜的诗人

最初的动作是歌唱
一种自由的声音，充塞山谷
最初的动作是喜悦
但它已被攫去

既然岁月已经改变了我的血
而成千的行星系统在我的肉体中生生死死
我坐着，一个灵巧而愤怒的诗人
眼睛斜视，满怀恶意
手中，掂量着笔
我密谋着复仇

我掌握着笔而它长出枝叶，满覆着花朵
而那树的气味是莽撞无礼的，因为在那现实的地球上
并不长有这种树，而那树的气味
对受苦的人类，像是一种侮辱

有些人避难于绝望，它甘美
如强烈的菸草，如在虚无时喝醉的一杯伏特加
其他的抱着蠢人的希望，玫红如淫艳的梦

另有一些人在爱国的盲目崇拜中找到安宁
它可以维持很久
虽然并不比十九世纪维持得更久

然而给我的却是一种冷嘲热讽的希望
因为自从睁开眼睛，我只看见火光、大屠杀
只见背信、侮辱，以及吹牛者可笑的羞耻
给我的是对别人与对自己复仇的希望
因为我是个了解它
而不为自己从中取利的人

逃亡

当我们离开那燃烧中的城市时
在第一条野径上，掉头回顾
我说∶”让野草覆盖我们的脚印吧
让无情的先知在火中沉默
且让死者告诉生者所发生的事
我们注定要生出一个新的、勇猛的种族
免于在那儿昏睡的罪恶与快乐
我们走吧 “于是一把火剑为我们劈开大地

哀歌

告诉我，对你是否太远
你原可奔过波罗地海的微浪
经过丹麦田野，经过山毛鹇树林
原可转向海洋，而那儿，不久
拉布拉多，在这时节是白色的
假如你，梦想一个孤岛的你
害怕城市以及公路沿途闪亮的灯光
你有一条小径直穿原野
俯视一片墨色溶溶的水面，野鹿与美洲驯鹿的足迹
远至锯齿山脉与放弃的金矿区
萨克拉门托河，原可引导你
在长满多刺橡树的山丘之间
然后只有尤隹利树林，而你找到了我

真的，当石南盛开
而海湾晴朗，在春日早晨
我无可奈何地想到，在那些湖
与立陶宛天空下拉上的网之间，那楝房子
你从前放衣服的浴室小房间
已永远变成一个抽象的水晶品
如蜜的黑暗在那儿，靠近游廊
以及好玩的小猫头鹰，以及皮革的气味

那时一个人怎能活下去，我真的不知道
神采与服装若隐若现，朦朦然
非自足的，趋向终局
我们渴望事物本身的原貌，这要不要紧
对火般岁月的了解烧焦了站在锻铁场那些马
市场里那些小圆柱
那些木梯，以及弗理吉尔托普妈妈的假发

我们学了那么多，这点你很知道∶
如何，逐渐地，不可能被剥夺
被剥夺。人民，乡村
而心并没有死，当人们以为它应该已死
我们微笑，桌上有茶和面包。
而且只悔恨我们没爱
在沙克森豪森的可怜的骨灰
以绝对的爱，超乎人的力量

你已习惯于新的、潮湿的冬天
习惯于别墅，那儿，德国主人的血
从墙上被洗掉，而他永远不再回来
我也接受可能以外的一切，城市和乡村
一个人不能两次踏进同一个湖
在赤杨的朽叶上
折断一道狭长的阳光

罪，你我的？不是大罪
秘密，你我的？不是大秘密
不是，当他们用手帕绑住下颚，将一个小十字架放在手指间
而某个地方狗吠，第一颗星突然闪亮

不，不是因为太远
那天或晚上你没有来造访我
年复一年，它在我们心中滋长，直到它完全掌握
我了解它，正如你一样∶泠漠

那么少

我说得那么少
日子短促

短暂的白昼
短暂的夜晚
短暂的岁月

我说得那么少
我不能继续说下去
我的心滋生着疲倦
由于喜悦
失望
热情
希望

海中巨兽的颚骨
紧咬着我

赤裸着，我躺在荒岛的
岸上

世界白色的鲸鱼
把我拖向它的深渊

现在我不知道
在一切中什么是真实

蟒蛇

我想说出真相
但感觉徒然

我试图坦白
却没有什么能够坦白

我不相信精神疗法
我知道我会说出不少谎言

如此，我带给自己一条缠绕着的愧疚——
它于我不是一个抽象的概念

我站在雅斯朱尼的拉乌杜尼卡湿地
一条蟒蛇拖着尾巴正消失在
矮松林下的苔藓

我扣动扳机，铅弹射出了霰弹枪
直到今天我也不知道是否有粒子弹
击中那可怕的白腹
或它背上的条形纹

较之心灵的种种冒险，无论如何
这叙述要容易得多

使命

在畏惧和颤栗中，我想我会完成我的使命
只当我促使自己提出公开的自白书
揭示我自己和我这时代的羞耻
我们被允许以侏儒和恶魔的口舌尖叫
而真纯和宽宏的话却被禁止
在如此严峻的惩罚下，谁敢说出一个字
谁就自认为是个失踪的人

尾声

因此是你的命运挥动你的魔杖
唤醒暴风雨，冲过暴风雨的中心
暴露纪念碑像灌木丛中的巢
虽然你曾想要的只是摘一些玫瑰

大地重光

我来了，何必这种莫名的恐惧
不久黑夜将离去，白天将升起
你听：牧羊人的号角已经
吹响。星光逐渐消失于红曦

“大道”很直：我们在边上
钟声敲响在下面的村庄
而篱笆上公鸡在欢迎
曙光；大地肥沃而快乐，冒着热气

这儿仍是黑暗，像泛滥的河水
浓雾笼罩黑簇簇的越橘
然而踩着高跷的黎明已进入水中
而带着铃声日球在滚动

感谢译诗库米沃什诗选

用静态工厂方法代替构造器

比如下面的代码，来自 Boolean 的简单示例

public static Boolean valueOf(boolean b) {
    return b ? Boolean.TRUE : Boolean.FALSE
}

通过静态工厂方法（区别于设计模式中的工厂方法），代替传统的公有构造器，向客户端提供实例，这么做的优势在于

• 静态工厂方法具有名称：这是显而易见的。另一方面，拥有多个参数的类很可能提供多个构造器，如何区分这些构造器就是问题。

• 静态工厂方法可以提供单例：从这个角度看，相当于实现了简单的单例模式。

• 静态工厂方法可以返回任何子类型的对象：典型的应用为Java.util.Collections类，其中定义了很多静态内部类比如EmptyList，并通过静态方法emptyList返回实现

• 静态工厂方法可以提供更简洁的实例化代码：实际上在较新的 JDK 版本已经去掉了多余的类型参数，但是静态工程方法确实可以做到更简洁

  List< String> strings = new ArrayList<>(); List< String> emptyList = Collections.emptyList();

静态工厂方法的缺点在于，第一如果类不包含公有构造器，则外部无法继承它——勉强算一个缺点吧——第二它与其他静态方法没有任何区别，只是返回的是自身的一个实例。这就造成如何类没有提供公有构造方法，那么外部调用者将苦恼于它的实例化。下面是一些静态工厂方法的惯用名称：

• valueOf：实际上属于类型转换方法
• of：上面名称的简洁形式
• getInstance：返回的实例通过方法参数描述。在单例模式中保证返回唯一的实例
• newInstance：跟上面的相似，但保证返回的实例与所有其他实例不同
• getType：不了解，Character提供了该工厂静态方法返回CharacterData的不同实现
• newType：不了解

多个构造器时考虑使用构建器

实际上就是使用简单的建造者模式实例化对象，还是通过代码说明

public class Human {

    private final String name;
    private final int height;
    private final int weight;

    public static class Builder {
        // 必要参数
        private final int name;

        // 可选参数
        private int height = 170;
        private int weight = 60;

        public Builder(String name) {
            this.name = name
        }

        public Builder height(int height) {
            this.height = height;
            return this;
        }

        public Builder weight(int weight) {
            this.weight = weight;
            return this;
        }

        public Human build() {
            return new Human(this);
        }
    }

    private Human(Builder builder) {
        name = builder.name;
        height = builder.height;
        weight = builder.weight;
    }

    public static void main(String[] args) {
        Human human = new Human.Builder("Jack")
                    .height(175)
                    .weight(60)
                    .build();
    }
}

这种方式广泛运用于 Java 开发中，优点显而易见，唯一的缺点可能为了创建对象需要先创建其建造器（不值一提）

使用私有构造器、枚举强化单例

其实就是单例模式，简单贴一下代码吧，忘记了可以回去看设计模式的笔记：Java设计模式：创建型模式

public class Singleton {  

    private volatile static Singleton singleton;  
    private Singleton (){}  
    
    public static Singleton getSingleton() {  
        if (singleton == null) {  
            synchronized (Singleton.class) {  
                if (singleton == null) {  
                    singleton = new Singleton();  
                }  
            }  
        }  
        return singleton;  
    }  
}

下面是枚举类型实现单例

public enum  Singleton {
    INSTANCE
}

通过私有构造器强化不可实例化的能力

用得最多的地方就是各种Util类，一般只有一个静态方法，实现一个简单的功能。最典型的例子就是java.lang.Math

划水而过

避免创建不必要的对象

最常见的例子就是 Java 的基本数据类型，直接使用int、char而不是它们的包装类型Integer、Character，因为基本数据类型直接保存在内存模型中的栈中，而且具有复用性，比对象类型更加节省内存

Java 的经典面试题中经常牵扯到String的实例化

String s0 = "9527";
String s1 = "9527";
System.out.println(s0 == s1);

String s2 = new String("9527");
System.out.println(s0 == s2);

（第一个比较是多余的，因为对于基本类型来说，==会直接比较他们的值）。一定范围内的基本数据类型会保存在栈内的常量池中。第一行代码，虚拟机首先创建一个引用s0，然后到常量池中寻找是否存在字面量为9527的值，如果有则直接返回栈地址，没有则新建一个常量9527并将s0指向它，然后返回。到了s1被创建的时候，根据上面的步骤，s1将直接指向s0所指向的栈地址

第二个比较结果显然是false。如果使用构造器构造一个String类型的变量，则虚拟机会先在栈中创建引用s2，在堆中开辟内存新建String对象，保存传入的参数9527，然后将堆地址指向栈内的s2

对于String来说，直接使用构造器更糟糕的一点还在于，其被声明为final，每new一次就创建一个对象。可以想象如果在循环中使用了构造器来创建字符串，将会造成多么大的内存浪费

消除过期的对象引用

通过一个栈的实现说明

public class Stack {
    private Object[] elements;
    private int size;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    
    public Stack() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }
    
    public void push(Object o) {
        ensureCapacity();
        elements[size++] = o;
    }
    
    public Object pop(){
        if (size == 0) 
            throw new EmptyStackException();
        return elements[--size];
    }
    
    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}

该实现的问题出现在，pop方法中弹出的对象将不会被系统回收，因为栈内部仍然维护着它们的过期引用，解决办法如下

public Object pop(){
    if (size == 0)
        throw new EmptyStackException();
    Object result = elements[--size];
    elements[size] = null;
    return result;
}

避免使用终结方法

终结方法其实就是Object内的finalize方法，其声明为

protected void finalize() throws Throwable { }

该方法是当 JVM 发现不可达对象时，将其回收之前调用的方法。问题在于，从发现该回收对象到真正回收这之间的时间是不确定的。JVM 不但不保证终结方法会被及时执行，甚至不保证其会被执行，如果重写终结方法，并期望在其中添加资源回收业务，将造成巨大隐患——资源可能永远都不会被回收。

使用终结方法的另一个弊端在于，如果子类重写了父类的finalize，但是却没有在其中调用父类的finalize，那么父类（非 Object）永远不会被回收。

好了，这就是第一章的划水内容。可以看到大都是一些有用的编程经验和技巧，用来时刻提醒自己不要犯低级的错误。可能这本书提及到的内容有些开发者一辈子都碰不到，但是要想成为一个卓越的工程师，注重细节和原理永远是不可获取的。这也算是对自己的勉励吧。

不知道是不是前面写 Dart、Gradle、Spring 的东西太多，突然这么轻松地写博客，竟然感到“周身血气运转通畅、心情愉悦”，简直好惨一博主。那下一篇也继续划水吧~

Spring MVC

跟踪请求

当用户在 Web 浏览器点击链接或提交表格的时候，发出的请求将通过一系列的路径，直到获取响应返回浏览器，这一过程在 Spring MVC 中的过程可以由上图展现

• 请求首先到达 DispatcherServlet，相当于一个前端控制器，其作用是查询处理器映射（Handler Mapping）后将请求发送给不同的 Spring MVC 控制器（Controller）
• 到达具体的控制器之后请求会卸下其负载信息，并等待控制器的处理结果
• 控制器完成逻辑处理后返回原始模型（Model）和视图名（View）
• DispatcherServlet 通过视图解析器（View Resolver）解析视图名得到匹配结果
• 请求最后到达视图实现（比如 JSP），交付模型数据
• 视图实现渲染输出模型并通过响应对象传递给客户端

搭建 Spring MVC

项目的结构图如上

Spring MVC 的核心是 DispatcherServlet，此处通过 Java 代码实现其配置，web.xml 文件的配置方式省略

class SpittrWebApplicationInitializer: AbstractAnnotationConfigDispatcherServletInitializer() {

    override fun getServletMappings(): Array = arrayOf("/")
    
    override fun getRootConfigClasses(): Array> = arrayOf(RootConfig::class.java)

    override fun getServletConfigClasses(): Array> = arrayOf(WebConfig::class.java)
}

原理（特别绕）：拓展 AbstractAnnotationConfigDispatcherServletInitializer 的类都会自动配置 DispatcherServlet 和 Spring 应用上下文（由 ContextLoaderListener 实现），因为容器会在类路径中查找实现 ServletContainerInitializer 接口的实现并为其配置，而Spring 中的实现为 SpringServletContainerInitializer，这个实现又会查找 WebApplicationInitializer——关于这个接口的继承关系为

public abstract class AbstractContextLoaderInitializer implements WebApplicationInitializer

public abstract class AbstractDispatcherServletInitializer extends AbstractContextLoaderInitializer

public abstract class AbstractAnnotationConfigDispatcherServletInitializer extends AbstractDispatcherServletInitializer

我们重写了三个方法

• getServletMappings：将“/”路径映射到 DispatcherServlet 上，这也让其成为默认 Servlet
• getRootConfigClasses：该方法返回的带有@Configuration注解的类将会用来配置应用上下文中的 bean
• getServletConfigClasses：要求 DispatcherServlet 加载应用上下文时，使用定义在 WebConfig 中的 bean

RootConfig 和 WebConfig 的实现如下

@Configuration
@ComponentScan(basePackages = ["spittr"], excludeFilters = [ComponentScan.Filter(type = FilterType.ANNOTATION, value = [EnableWebMvc::class])])
open class RootConfig

@EnableWebMvc
@Configuration
@ComponentScan(value = ["spittr.web"])
open class WebConfig: WebMvcConfigurerAdapter() {

    @Bean
    open fun viewResolver(): ViewResolver = InternalResourceViewResolver().apply {
        setPrefix("/WEB-INF/views/")
        setSuffix(".jsp")
        setExposeContextBeansAsAttributes(true)
    }

    override fun configureDefaultServletHandling(configurer: DefaultServletHandlerConfigurer?) {
        configurer?.enable()
    }
}

RootConfig 使用@ComponentScan以实现对非 Web 组件的调用。

WebConfig 使用@EnableWebMvc启动 Spring MVC，使用@ComponentScan启用组件扫描，并继承 WebMvcConfigurerAdapter 重写其configureDefaultServletHandling方法以实现将静态资源的转发给默认 Servlet （貌似是多余的），同时添加一个 ViewResolver bean 查找对应的视图文件

Spring 控制器

基本用法

在 Spring MVC 中，控制器是指添加了@RequestMapping注解的类，无论是在方法还是类上。控制器本身所带的@Controller则影响不大，如下面的代码。注解上的参数为数组，说明可以映射多个路径、多个请求类型。home返回的字符串将配合上面 WebConfig 的viewResolver方法寻找网页视图

@Controller
class HomeController {

    @RequestMapping(value = ["/"], method = [RequestMethod.GET])
    fun home(): String {
        return "home"
    }
}

现在就可以通过配置 Tomcat 运行本地服务器检验项目了，首先需要下载 Tomcat 包并解压，在 IDEA 中EDIT Configurations，添加一个 local 的 Tomcat，添加完成之后大概如下

接下来还有最重要的一部，否则会出现一个很奇怪的错误

java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener

这是因为项目中通过 Maven 引入的库并没有被 Tomcat 识别，需要手动添加，如下图，点击左下角的编辑图标

在右侧的Available Elements中右键项目spittr，选择Put into Output Root，成功之后左侧的WEB-INF/lib下应该有需要的库

配置结束，需要注意的是不要导入 IDEA 生成的 Spring Web 框架，因为我们已经使用了 Maven 导入所有项目需要的类库，而且配置文件都是通过 Java 代码而没有引入任何的 XML 文件（除了 Maven 的pom.xml）。成功运行项目之后，浏览器打开http://localhost:8080/spittr_war_exploded/即可看到home.jsp中的网页视图

传递数据到视图中

首先建立数据模型，定义一条Spittr的内容为Spittle，同时通过一个仓库接口对外提供数据

data class Spittle(val id: Long, val message: String, val time: Date, val latitude: Double, val longitude: Double)

interface SpittleRepository {
    fun findSpittles(max: Long, count: Int): List
}

@Component
class SpittleRepositoryImpl: SpittleRepository {

    override fun findSpittles(max: Long, count: Int): List {
        return createSpittles(count)
    }

    private fun createSpittles(count: Int): List {
        val spittles: MutableList = ArrayList()
        for (i in 0 until count) {
            spittles.add(Spittle(id = i.toLong(), message = "This is spittle$i", time = Date(), latitude = Math.random(), longitude = Math.random()))
        }
        return spittles
    }
}

配置对应的控制器 SpittleController

@Controller
@RequestMapping("/spittles")
class SpittleController
@Autowired constructor(private val spittleRepository: SpittleRepository) {

    @RequestMapping(method = [RequestMethod.GET])
    fun spittles(model: Model): String {
        model.addAttribute("spittleList", spittleRepository.findSpittles(Long.MAX_VALUE, 20))
        return "spittles"
    }
}

相应的 JSP 页面为spittles.jsp

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>SpittleListtitle>
head>
<body>
    <c:forEach items="${spittleList}" var="spittle">
        <li id="spittle_spittle.id"/>">
            <div class="spittleMessage">
                <c:out value="${spittle.message}"/>
            div>
            <div>
                <span lass="spittleTime">
                    <c:out value="${spittle.time}" />
                span>
                <span class="spittleLocation">
                    (<c:out value="${spittle.latitude}" />
                    <c:out value="${spittle.longitude}" />)
                span>
            div>
        li>
    c:forEach>
body>
html>

需要注意的是，使用 JSTL 需要通过 Maven 引入两个库，参考这里——最重要的一步，将下载好之后的类库添加进 Tomcat lib 文件夹中

运行项目之后在浏览器打开http://localhost:8080/spittr_war_exploded/spittles即可查看效果

接受请求输入

Spring MVC 允许多种方式将客户端中的数据传送到控制器的处理方法中

• 查询参数（Query Parameter）
• 表单参数（Form Parameter）
• 路径变量（Path Parameter）

处理查询参数

添加一个新功能，让用户可以查看某一页的 Spittle 历史，为此需要获得一个 Spittle 的 ID——其恰好小于当前页最后一条 Spittle 的 ID。修改 SpittleController 中的方法

@RequestMapping(method = [RequestMethod.GET])
fun spittles(
        @RequestParam("max", defaultValue = Long.MAX_VALUE.toString()) max: Long,
        @RequestParam("count", defaultValue = "20") count: Int,
        model: Model): String {
    model.addAttribute("spittleList", spittleRepository.findSpittles(max, count))
    return "spittles"
}

现在客户端可以通过再链接后添加可选的查询参数获得不同的结果，比如http://localhost:8080/spittr_war_exploded/spittles?count=5将显示 5 条 Spittle

处理路径参数

假设应用程序需要根据给定的 ID 展现某一条 Spittle 记录，从面向资源的角度，这时 Spittle 应该通过 URL 路径标示，而不是通过查询参数，控制器添加新的方法，同时 SpittleRepository 添加一个查询单个 Spittle 的新接口

@RequestMapping(value = ["/{spittleId}"])
 fun showSpittle(@PathVariable spittleId: Long, model: Model ): String {
     model.addAttribute("spittle", spittleRepository.findSpittle(spittleId))
     return "spittle"
 }

 override fun findSpittle(id: Long): Spittle {
     return Spittle(id = id, message = "This is spittle$id", time = Date(), latitude = Math.random(), longitude = Math.random())
 }

运行项目，现在就可以通过在原有路径上添加/id的方式访问特定的 Spittle，比如http://localhost:8080/spittr_war_exploded/spittles/9527

处理表单

为 Spittr 提供用户注册和通过username查看个人信息的接口，为此首先要定义一个用户类型 Spitter 以及对应的 Repository。需要注意的是，使用 Kotlin 的data class时，属性要添加默认值并且要使用var而不能用val，不符合其中一个条件，提交表格时 Spring 都不能实例化 Spitter。同时还引入了javax.validation.validation-api包进行错误检验

data class Spitter(@NotNull @Size(min = 3, max = 16) var firstName: String = "",
              @NotNull @Size(min = 3, max = 16) var lastName: String = "",
              @NotNull @Size(min = 3, max = 16) var username: String = "",
              @NotNull @Size(min = 3, max = 16) var password: String = "")

interface SpitterRepository {
    fun save(spitter: Spitter)
    fun findByUsername(username: String): Spitter?
}

@Component
class SpitterRepositoryImpl: SpitterRepository {

    private val spitterMap: MutableMap = HashMap()

    override fun save(spitter: Spitter) {
        spitterMap[spitter.username] = spitter
    }

    override fun findByUsername(username: String): Spitter? = spitterMap[username]
}

添加一个控制器 SpitterController，实现下面的逻辑：用户打开/spitter/register页面时显示注册页面，其中包含一个表单。提交注册信息之后，判断注册信息有误错误，正确则重定向至/spitter/username路径，展示 Profile 信息

奇怪的是当表单参数不符合注解要求时并不会触发 Error，尚不知道原因，已排除 Kotlin 代码的问题

@Controller
@RequestMapping("/spitter")
class SpitterController
@Autowired constructor(private val spitterRepository: SpitterRepository) {

    @RequestMapping(value = ["/register"], method = [RequestMethod.GET])
    fun showRegistrationForm(): String = "registerForm"

    @RequestMapping(value = ["/register"], method = [RequestMethod.POST])
    fun processRegistration(@Validated spitter: Spitter, errors: Errors): String {
        if (errors.hasErrors()) {
            return "registerForm"
        }
        spitterRepository.save(spitter)
        return "redirect:/spitter/${spitter.username}"
    }

    @RequestMapping(value = ["/{username}"], method = [RequestMethod.GET])
    fun showSpitterProfile(@PathVariable username: String, model: Model): String {
        val spitter = spitterRepository.findByUsername(username)
        model.addAttribute("spitter", spitter)
        return "profile"
    }
}

需要准备两个 View 文件，registerForm.jsp和profile.jsp。第一个文件如下

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Spittertitle>
head>
<body>
    <h1>Registerh1>

    <form method="post" action="register">
        First Name: <input type="text" name="firstName"><br>
        Last Name: <input type="text" name="lastName"><br>
        User Name: <input type="text" name="username"><br>
        Password: <input type="password" name="password"><br>

        <input type="submit" value="Register">
    form>
body>
html>

第二个文件为

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Profiletitle>
head>
<body>
    <h1>Spitter Profileh1>
    <c:out value="Username is ${spitter.username}" /><br>
    <c:out value="First name is ${spitter.firstName} " />
    <c:out value="and last name is ${spitter.lastName}" />
body>
html>

运行项目即可检验开发成果

最后再给出主页视图的文件home.jsp，关于本章的内容基本就是这样

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Spittrtitle>
head>
<body>
    <h1>Welcome to Spittrh1>

    <a href="spittles" />">Spittlesa> |
    <a href="spitter/register" />">Registera>
body>
html>

面向切面编程

Aspect-Oriented Programming，AOP。每个应用除了其核心业务之外，还会需要一些模块化的通用功能——比如日志、安全、通知等。重用通用功能的方式一般有继承（inheritance）、 委托（delegation），缺点在于前者会导致对象体系复杂、难以维护，后者则可能需要对委托对象进行复杂的调用。切面提供了不一样的思路，并且在很多场景下更加清晰简洁。

AOP 术语

Advice

通知，如果翻译为“增强”就能更直观地理解它所扮演的角色。Spring 切面可以应用 5 种类型的通知

• 前置通知（ Before ）：在目标方法被调用之前调用通知功能
• 后置通知（ After ）：在目标方法完成之后调用通知，不关心方法的返回值
• 返回通知（ After-returning ）：在目标方法成功执行之后调用通知
• 异常通知（ After-throwing ）：在目标方法抛出异常之后调用通知
• 环绕通知（ Around ）：通知包裹了被通知的方法，在被通知的方法调用之前喝调用之后执行自定义的行为

Joint point

连接点，应用可能有数以千计的时机应用通知，这些时机被称为连接点。根据上面的图理解，连接点是在应用执行过程中能够插入切面的一个点，改点可以是调用方法时、抛出异常时、甚至修改一个字段时。

Pointcut

切点，通知定义了切面的“什么”和“何时”，连接点定义了“时间点”，切点则定义了“何处”。切点会匹配通知所要织入的一个或多个连接点。通常使用明确的类和方法名称、或者使用正则表达式定义所匹配的类和方法来指定切点，有些 AOP 框架也会允许动态创建切点。

Aspect

切面，通知+切点，这两者共同定义了切面的全部内容

Introduction

引入，允许开发者向现有的类添加方法或属性

Weaving

织入，把切面应用到目标对象并创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中，在目标对象的生命周期里有多个点可以进行织入：

• 编译期：切面在目标类编译时被织入。需要特殊的编译器，如 AspectJ 的织入编译器
• 类加载期：切面在目标类加载到 JVM 时被织入。这种方式需要特殊的类加载器，从而在目标类被引用之前增强其字节码。比如 AspectJ 5 的加载时织入（load-time weaving，LTW）
• 运行期：切面在应用运行的某个时刻被织入。一般情况下，织入时 AOP 容器会为目标对象动态地创建一个代理对象。比如 Spring AOP

Spring AOP

Spring 提供了 4 中类型的 AOP 支持：

• 基于代理的经典 Spring AOP
• 纯 POJO 切面
• @AspectJ注解驱动的切面
• 注入式 AspectJ 切面

相比起其他方式，第一种显得笨重而古典，不再介绍。纯 POJO 切面需要借助 Spring 的 aop命名空间，虽然足够简便，但也不再赘述。Spring 借鉴了 AspectJ 的切面以提供注解驱动的 AOP，其本质仍然是代理，但是编程模型几乎与成熟的 AspectJ 注解完全一致。如果开发者对 AOP 的需求超过了简单的方法调用（如构造器或属性拦截），那么可以考虑第四种方式——使用 AspectJ。

通过再代理类中包裹切面，Spring 在运行期把切面织入到 Spring 管理的 bean 中。代理类封装了目标类并拦截被通知方法的调用，再把调用转发给真正的目标 bean

由于 Spring AOP 基于动态代理，所以只支持方法连接点，不支持字段连接点——无法创建细粒度的通知、不支持构造器连接点——无法在 bean 创建时应用通知。

通过切点选择连接点

使用 AspectJ 的切点表达式语言来定义切点。Spring 仅支持 AspectJ 切点指示器的一个子集，因为 Spring 基于代理，而某些切点表达式与代理无关。下表是 Spring AOP 所支持的指示器

尝试使用其他指示器时，将抛出IllegalArgumentException异常

以上的指示器只有execution()指示器是实际执行匹配的，其他指示器都是用来限制匹配的。

编写切点

准备一个主题 Performance，可代表任何类型的现场表演，假设要编写其中perform方法触发的通知

package concert

interface Performance {
    fun perform()
}

使用 AspectJ 表达式编写切点

execution(* concert.Performance.perform(..)) && within(concert.*)

使用execution()指示器选择perform方法，方法表达式以*开始表示不关心返回值类型，然后使用全限定类名和方法名；使用两个点号..表示不关心方法参数列表，切点会选择为所有的perform方法。&&操作符把execution()和within指示器连接在一起形成与（and）关系，限制需要配置的切点仅匹配concert包，类似也可以使用||和!来标识或（or）和非（not）操作

当然也可以通过 Spring 引入的指示器bean()指示特定的 bean，参数为 bean 的 id

execution(* concert.Performance.perform(..)) && bean('woodstock')
execution(* concert.Performance.perform(..)) && !bean('woodstock')

使用注解创建切面

简单通知

对于一场演出，我们将“观众”定义为切面

@Aspect
class Audience {

    @Before("execution(** concert.Performance.perform(..)")
    fun silenceCellPhones() {
        println("Silencing cell phones")
    }

    @Before("execution(** concert.Performance.perform(..)")
    fun takeSeats() {
        println("Taking seats")
    }

    @AfterReturning("execution(** concert.Performance.perform(..)")
    fun applause() {
        println("CLAP CLAP CLAP!!")
    }

    @AfterThrowing("execution(** concert.Performance.perform(..)")
    fun demandRefund() {
        println("Demanding a refund")
    }
}

AspectJ 库需要通过依赖引入

Audience 定义了四个方法，通过 AOP 注解，形成以下期望的行为——演出之前观众就坐、将手机静音，演出很精彩则鼓掌欢呼，演出没有达到预期则要求退款。以上的方式有一点不足，每个方法的切点表达式都是一样的，重复了四次。为此可以使用@Pointcut注解定义可重用的切点

@Aspect
class Audience {

    @Pointcut("execution(** concert.Performance.perform(..))")
    fun performance(){ }
    
    @Before("performance()")
    fun silenceCellPhones() {
        println("Silencing cell phones")
    }

    @Before("performance()")
    fun takeSeats() {
        println("Taking seats")
    }

    @AfterReturning("performance()")
    fun applause() {
        println("CLAP CLAP CLAP!!")
    }

    @AfterThrowing("performance()")
    fun demandRefund() {
        println("Demanding a refund")
    }
}

除了注解和作为标识的空performance方法，Audience 仍然是一个 POJO，可以添加@Component注解将其注入容器中。但此时 Audience 不会视为切面，需要在配置类的的类级别通过使用@EnableAspectJAutoProxy注解启动自动代理功能

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
open class ConcertConfig

同时为 Performance 提供一个实现类

@Component
open class MyPerformance: Performance {
    
    override fun perform() {
        println("Start perform")
    }

}

测试类如下

@RunWith(SpringJUnit4ClassRunner::class)
@ContextConfiguration(classes = [ConcertConfig::class])
class PerformTest {
    
    @Autowired
    lateinit var performance: Performance

    @Test
    fun perform() {
        performance.perform()
    }
}

输出结果为

Silencing cell phones
Taking seats
Start perform
CLAP CLAP CLAP!!

环绕通知

环绕通知时最强大的通知类型，能够使编写的逻辑将被通知的目标方法完全包装，就像 在一个通知方法中同时编写前置通知和后置通知，重写上面的 Audience 切面

@Aspect
@Component
class Audience {

    @Pointcut("execution(** concert.Performance.perform(..))")
    fun performance(){ }

    @Around("performance()")
    fun watchPerformance(jointPoint: ProceedingJoinPoint) {
        try {
            println("Silencing cell phones")
            println("Taking seats")
            jointPoint.proceed()
            println("CLAP CLAP CLAP!!")
        } catch (e: Exception) {
            println("Demanding a refund")
        }
    }
}

上面的代码将实现同样的功能。环绕通知注解的方法watchPerformance中类型为ProceedingJoinPoint的参数是必须的，由此拿到切点的引用

带参数的通知

通过一个例子来展现带参数的通知如何实现，首先修改 MyPerformance 类

@Component
open class MyPerformance: Performance {

    private var performList: List = arrayListOf("Song", "Dance", "Magic")

    override fun perform() {
        perform(Math.round(10f) % 2)
    }

    override fun perform(type: Int) {
        println("Start perform: ${performList[type]}")
    }
}

假设现在有一个计数类 PerformanceCounter，其将跟踪每一次表演节目，记录下该节目的类型以及次数并打印

@Aspect
@Component
class PerformanceCounter {

    private var playCounter: MutableMap<Int, Int> = HashMap()

    @Pointcut("execution(** concert.Performance.perform(..)) && args(whichType)")
    fun performanceTypePlay(whichType: Int) { }

    @After("performanceTypePlay(typeIntValue)")
    fun countPerformance(typeIntValue: Int) {
        val currentCount = getPlayCount(typeIntValue)
        playCounter[typeIntValue] = currentCount+1
        println("=== type: ${getDesByInt(typeIntValue)}, played ${currentCount+1} times ===")
    }

    private fun getPlayCount(type: Int): Int = playCounter[type] ?: 0

    private fun getDesByInt(type: Int): String = when(type) {
        0 -> "Song"
        1 -> "Dance"
        2 -> "Magic"
        else -> "null"
    }
}

着重注意不同方法中的type参数，参数名称各有不同，但本质都代表“表演类型”。而相同的参数名称则表示一一对应的关系：定义切点时，AspectJ 表达式内使用的参数名称为whichType，与标识该切点的空函数的参数是一致的；通知方法上的参数名称typeIntValue则与通知时机中引用切点时 AspectJ 表达式内的参数名称一致

测试类如下

@RunWith(SpringJUnit4ClassRunner::class)
@ContextConfiguration(classes = [ConcertConfig::class])
class PerformTest {

    @Autowired
    lateinit var performance: Performance

    @Test
    fun perform() {
        for (i in 0..4) {
            performance.perform(i % 3)
        }
    }
}

控制台输出为

Start perform: Song
=== type: Song, played 1 times ===
Start perform: Dance
=== type: Dance, played 1 times ===
Start perform: Magic
=== type: Magic, played 1 times ===
Start perform: Song
=== type: Song, played 2 times ===
Start perform: Dance
=== type: Dance, played 2 times ===

注入 AspectJ 切面

AspectJ 和 Spring 实际上是独立的，只不过 Spring AOP 借助了前者的指示器。通过一个例子展示如何注入原始的 AspectJ 切面。

首先准备一个评论员，在表演之后发表一段言论，其类型为aspect，在 IDEA 中可通过右键 New -> Aspect 新建一个该类型的文件

public aspect CriticAspect {

    public CriticAspect() { }

    pointcut performance(): execution(* concert.MyPerformance.perform(..));

    after(): performance() {
        System.out.println("something");
    }

}

在 Spring 框架中，CriticAspect 将不会由容器创建，因为它属于 AspectJ 切面，由 AspectJ 在运行时创建。所以需要通过 AspectJ 切面提供的静态aspectOf方法给 Spring 返回切面的单例，Spring XML 配置写成以下形式

<beans ...>

    <context:component-scan base-package="concert" />

    <aop:aspectj-autoproxy />

    <bean class="concert.CriticismEngineImpl" id="criticismEngine" />

    <bean class="concert.MyPerformance" id="performance" />

    <bean class="concert.CriticAspect" factory-method="aspectOf" />
beans>

如果是 JavaConfig，则需要以下形式

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
open class ConcertConfig {
    @Bean
    open fun criticAspect(): concert.CriticAspect = org.aspectj.lang.Aspects.aspectOf(CriticAspect::class.java)
}

但是运行时 JRE 将不会识别类 CriticAspect，无法运行。目前未找到解决办法，故使用 XML 配置的方法

之后最重要的一步是使用ajc编译器，以编译.aj文件。通过一个插件 Mojo’s AspectJ Maven Plugin 引入ajc，注意此时 IDEA Compiler 的选项截图为

测试类如下

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:concert.xml"})
public class PerformTest {

    @Autowired
    Performance performance;

    @Test
    public void test() {
        performance.perform();
    }
}

按理说应该运行成功，然而此时还是报错

Error:ajc: can't find critical required type java.io.Serializable
Error:ajc: can't determine whether missing type java.io.Serializable is an instance of concert.CriticAspect
......
Error:ajc: can't find critical required type java.lang.Cloneable
Error:ajc: can't determine whether missing type java.lang.Cloneable is an instance of concert.CriticAspect
......

目前并无解决办法， V2EX 上的求助帖为 诚心求助 Spring 注入式 AspectJ 切面时 ClassNotFoundException 的问题

Spring AOP 的内容到此为止，日后大概率会对本篇文章进行增删查改，继续进行下一步的学习吧

Spring profile

配置 profile

使用注解@Profile指定某个 Bean 属于哪一个 profile，以不同环境下的数据库 Bean 为例

@Configuration
open class DataSourceConfig {
    
    @Bean
    @Profile("dev")
    open fun embeddedDataSource(): DataSource = EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .addScript("classpath:schema.sql")
            .build()

    @Bean
    @Profile("prod")
    open fun jndiDataSource(): DataSource {
        val jndiObjectFactoryBean = JndiObjectFactoryBean()
        jndiObjectFactoryBean.jndiName = "jndi/myDS"
        jndiObjectFactoryBean.isResourceRef = true
        jndiObjectFactoryBean.setProxyInterface(javax.sql.DataSource::class.java)
        return jndiObjectFactoryBean.`object` as DataSource
    }
}

同样支持使用 XML 文件配置 profile

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd"
       profile="dev">
    <jdbc:embedded-database id="dataSource2">
        <jdbc:script location="classpath:schema.sql" />
    < /jdbc:embedded-database>
beans>

可以将 profile 设置为prod，创建适用于生产环境的 JNDI 获取的 DataSource Bean，所有的配置文件都会被放进部署单元之中（如 WAR 文件），但是只有 profile 属性与当前激活 profile 相匹配的配置文件才会被使用。

不过更方便的方法是把所有的 Bean 放进同一个配置文件中

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd">

    <beans profile="dev">
        <jdbc:embedded-database id="dataSource">
            <jdbc:script location="classpath:schema.sql" />
        jdbc:embedded-database>
    beans>

    <beans profile="prod">
        <jee:jndi-lookup id="dataSource"
                         jndi-name="jdbc/myDS"
                         resource-ref="true"
                         proxy-interface="javax.sql.DataSource" />
    beans>
beans>

激活 profile

Spring 借助两个独立的属性spring.profiles.active、spring.profiles.default来确定哪个 profile 处于激活状态，优先级从高到低。如果两个值都没有设置，那就没有激活的 profile，此时只会创建那些没有定义在 profile 中的 Bean。以下是设置这两个属性的方式

• 作为 DispatcherServlet 的初始化参数
• 作为 Web 应用的上下文参数
• 作为 JNDI 条目
• 作为环境变量
• 作为 JVM 的系统属性
• 在集成测试类上，使用@ActiveProfiles注解设置

例如在 Web 应用中，设置spring.profiles.default的 web.xml 文件如下

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>spring.profiles.defaultparam-name>
        <param-value>devparam-value>
    context-param>
    
    <servlet>
        <servlet-name>appServletservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet
        servlet-class>
        <init-param>
            <param-name>spring.profiles.defaultparam-name>
            <param-value>devparam-value>
        init-param>
    servlet>
web-app>

该文件分别为上下文和 Servlet 设置了默认的 profile。当应用程序部署到 QA、生产或者其他环境中时，负责部署的人根据情况使用系统属性、环境变量或 JNDI 设置spring.profiles.active即可——其优先级比spring.profiles.default高

条件化的 Bean

使用 Spring 提供的注解@Conditional，可以实现 Bean 在符合条件的情况下才会配置的效果，不符合条件则该 Bean 会被忽略。下面的例子假设只有设置了magic环境属性时 Spring 才会实例化 MagicBean（事先准备），否则它将被忽略。

@Configuration
open class MagicConfig {

    @Bean
    @Conditional(MagicExistsCondition::class)
    open fun magicBean(): MagicBean = MagicBean()

}

@Conditional需要一个class参数，并且该类要实现Condition接口，重写方法match，如果该方法返回 true 则创建带有@Conditional的 Bean。

class MagicExistsCondition: Condition {
    
    override fun matches(p0: ConditionContext?, p1: AnnotatedTypeMetadata?): Boolean {
        val env = p0?.environment
        return env?.containsProperty("magic") ?: false
    }
    
}

该方法传入两个参数，第一个为ConditionContext

public interface ConditionContext {
    BeanDefinitionRegistry getRegistry();

    ConfigurableListableBeanFactory getBeanFactory();

    Environment getEnvironment();

    ResourceLoader getResourceLoader();

    ClassLoader getClassLoader();
}

可以看到该参数为我们提供了很多接口。第二个参数为AnnotatedTypeMetadata

public interface AnnotatedTypeMetadata {
    boolean isAnnotated(String var1);

    Map getAnnotationAttributes(String var1);

    Map getAnnotationAttributes(String var1, boolean var2);

    MultiValueMap getAllAnnotationAttributes(String var1);

    MultiValueMap getAllAnnotationAttributes(String var1, boolean var2);
}

该参数为我们提供了一系列检查@Bean方法上的其他注解的接口

观察第一节提到的Profile注解

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({ProfileCondition.class})
public @interface Profile {
    String[] value();
}

可以看到其本身也使用了@Conditional，引用ProfileCondition.class作为 Condition 实现

class ProfileCondition implements Condition {
    ProfileCondition() {
    }

    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        if (context.getEnvironment() != null) {
            MultiValueMap attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
            if (attrs != null) {
                Iterator var4 = ((List)attrs.get("value")).iterator();

                Object value;
                do {
                    if (!var4.hasNext()) {
                        return false;
                    }

                    value = var4.next();
                } while(!context.getEnvironment().acceptsProfiles((String[])((String[])value)));

                return true;
            }
        }

        return true;
    }
}

该类通过 AnnotatedTypeMetadata 获得用于@Profile注解的所有属性，然后检查value属性，得到profile名称。然后通过 ConditionContext 检查该profile是否激活

自动装配的歧义性

在自动装配中，只有当仅有一个 Bean 匹配所需的结果时，自动装配才是有效的，出现歧义则将阻碍 Spring 自动装配属性、构造器参数或方法参数。

比如下面的例子，提供两个 CompactDisc 的实现类

interface CompactDisc {
    fun play()
}

@Component
class SgtPeppers: CompactDisc {
......
}

@Component
class BlankDisc: CompactDisc {
......
}

测试代码为

@RunWith(SpringJUnit4ClassRunner::class)
@ContextConfiguration(classes = [CDPlayerConfig::class])
class CDPlayerTest {

    private lateinit var cd: CompactDisc

    @Test
    fun play() {
    cd.play()
    }

    @Autowired
    fun setCompactDisc(cd: CompactDisc) {
        this.cd = cd
    }
}

测试将会报错

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'soundsystem.CompactDisc' available: expected single matching bean but found 2: blankDisc,sgtPeppers

针对这种情况，可以使用@Primary和@Qualifier解决

@Primary

在其中一个实现上添加注解

@Component
@Primary
class SgtPeppers: CompactDisc {
......
}

该注解也可以应用在 JavaConfig 代码中，在 XML 文件的配置方式为

<bean id="sgtPeppers" class="sound_system.SgtPeppers"
    primary="true">
bean>

@Qualifier

该注解比@Primary更加灵活，使用简单

@Autowired
@Qualifier("sgtPeppers")
fun setCompactDisc(cd: CompactDisc) {
this.cd = cd
}

为@Qualifier注解设置的参数就是想要注入的 Bean 的 id，一般为 Bean 的类名首字母变为小写之后的字符。当然开发者也可以自定义 Bean 的限定符防止重命名之后原来的注解失效

@Component
@Qualifier("byBeatles")
class SgtPeppers: CompactDisc {

    private val title = "Sgt. Pepper's Lonely Hearts Club Band"
    private val artist = "The Beatles"

    override fun play() {
        println("Playing $title by $artist")
    }
}

相应的代码也更改为

@Autowired
@Qualifier("byBeatles")
fun setCompactDisc(cd: CompactDisc) {
this.cd = cd
}

更进一步，开发者可以自定义一个使用@Qualifier注解的注解类，防止以后再出现一个byBeatles的 Bean

import org.springframework.beans.factory.annotation.Qualifier

@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD, AnnotationTarget.TYPE, AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
@Qualifier
annotation class FavoriteCD

使用方法和@Qualifier("id")类似，在需要注解的类上添加@FavoriteCD，然后在自动装配的地方同样使用该注解即可。

Bean 的作用域

在上一篇文章中我们提到 Spring 中的 Bean 默认是单例的，但是显然这样的实例将会保持一定的“状态”，因此重用将是不安全的。Spring 定义了多种 Bean 作用域

• 单例（Singleton）：整个应用中只创建 Bean 的一个实例
• 原型（Prototype）：每次注入或者通过 Spring 应用上下文获取的时候都会创建一个新的实例
• 会话（Session）：在 Web 应用中，为每个会话创建一个实例
• 请求（Request）：在 Web 应用中，为每个请求创建一个实例

要使用作用域，可以通过@Scope注解实现

@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
class SgtPeppers

当然在自动装配的地方使用该注解也可以，XML 文件的配置方式同理，不再赘述

会话和请求作用域

在典型的电子商务应用中，可能有一个 Bean 代表用户的购物车，当其为单例时意味着所有的用户共用一个购物车。这种情况下使用会话作用域显然更加合适

@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION,
        proxyMode = ScopedProxyMode..TARGET_CLASS)
open class ShoppingCart

注解的第一个参数value将告诉 Spring 为 Web 应用的每个会话创建一个 ShoppingCart，在会话相关的操作中其相当于一个单例。第二个参数proxyMode被设为ScopedProxyMode.INTERFACES，解决将会话或者请求作用域的 Bean 注入到单例 Bean 中所遇到的问题

假设 ShoppingCart 注入到一个单例 StoreService 中，由于单例 Bean 会在 Spring 应用上下文加载的时候创建，然而此时属于会话作用域的 ShoppingCart 并不存在；此外，系统中将会有多个 ShoppingCart 实例，我们并不想让某一个固定的 ShoppingCart 实例到 StoreService 中，而是希望当 StoreService 处理购物车功能时，其所使用的 ShoppingCart 实例刚好是当前会话所对应的那个

proxyMode的作用就在于，Spring 不会将实际的 ShoppingCart 注入到 StoreService 中，而是将它的代理注入。这一代理会暴露与 ShoppingCart 相同的方法，所以 StoreService 会认为它就是一个购物车。当 StoreService 调用方法时，代理会进行懒解析并将调用委托到会话作用域内真正的 ShoppingCart 实例

XML 方式配置不再赘述

Spring 表达式语言

Spring Expression Language，简称 SpEL，能够以一种强大和简洁的方式将值装配到 Bean 属性和构造器参数中。其有很多特性

• 使用 ID 来引用 Bean
• 调用方法和访问对象的属性
• 对值进行算数、关系和逻辑运算
• 正则表达式匹配
• 集合操作

SpEL 要放到#{ ... }中，与属性占位符放到${ ... }中类似。对于下面的表达式

#{T(System).currentTimeMillis()}

将得到表达式计算的那一刻时间的毫秒数。T()表达式将其中参数视为 Java 中的类型，从而可以调用该类型的静态方法。

#{ ... }中既可以放字面值如整数、浮点数、字符串、布尔值，也可以引用对象属性和方法

#{sgtPeppers.artist}

#{systemProperties['sgtPeppers.title']}

#{sgtPeppers.toString()?.toUpperCase}

上面的第二个表达式将调用properties文件中sgtPeppers的title属性值。第三个参数表示我们可以对方法返回值使用安全调用

SpEL 支持各种常用的运算，包括算术运算、比较运算、逻辑运算、条件运算（? :和?:）、正则表达式（matches），下面是一个正则表达式的例子，用以验证邮箱

#{admin.email matches '[a-zA-Z0-9._&+-]+@[a-zA-Z0-9._&+-]'+\\.com}

下面是一个操作集合的例子

#{cd.tracks[1].title}

#{'the string'[1]} //得到 h

#{cd.tracks.?[title eq 'Title'} //得到 title 为 Title 的新集合

#{cd.tracks.^[title eq 'Title'} //得到第一个 title 值为 Title 的元素
              
#{cd.tracks.$[title eq 'Title'} //得到最后一个 title 值为 Title 的元素             

#{cd.tracks.![title]} //得到 title 的集合

关于

Spring

一个 Java EE 框架，同来替代更加重量级的企业级 Java 技术。其起源可以追溯到作者 Rod Johnson 2002年编写的《Expert One-to-One J2EE Design and Development》一书，书中他提出了一种基于普通 Java 类和依赖注入的解决方案。Rod Johnson 编写了超过30,000行基础结构代码，这便是最初的 Spring 框架。

Spring 的基本理念在于：简化 Java 开发，为此采用了4种关键措施：

• 基于 POJO 的轻量级和最小侵入性编程
• 通过依赖注入和面向接口实现松耦合
• 基于切面和惯例进行声明式编程
• 通过切面和模板减少样板式代码

依赖注入

依赖注入（Dependency Injection，简称 DI）是最常见的控制反转（Inversion of Control，简称 IoC）方式，是面向对象编程中的一种设计原则，用于减少代码之间的耦合度。系统通过引入实现 IoC 模式的容器，管理对象的声明周期、依赖关系，常用的 IoC 容器有 Spring 、JBoss、EJB 等。可以把 IoC 模式看作工厂模式的升华，区别在于该工厂要生成的对象是通过 XML 文件、配置类或者注解来配置。

Java 项目大都是由众多类组成，这些类相互协作来完成特定的业务逻辑。传统的做法是每个对象负责管理与自己相互协作的对象（即它所依赖的对象）的引用，导致代码高度耦合。耦合具有两面性，一方面，紧密耦合的代码难以测试、难以复用、难以理解，并且修复 Bug 的过程中容易引发更多的 Bug；另一方面，一定的耦合又是必须的——完全无耦合的代码什么也做不了。通过 DI，对象的依赖关系交由系统中负责协调各对象的第三者在创建对象时设定，依赖关系被注入到需要它们的对象中。

通过一个简单的 Spring Demo 引入依赖注入的思想。

项目结构如下

├─src
│  ├─main
│  │  ├─java
│  │  │  └─knigt
│  │  │          BraveKnight.kt
│  │  │          SlayDragonQuest.kt
│  │  │          KnightConfig.kt
│  │  │          KnightMain.kt
│  │  │
│  │  └─resources
│  │          knights.xml

在 IDEA 内通过以下命令生成项目文档树

tree >> D:/tree.txt 输出文件夹
tree /f >> D:/tree.txt 输出文件夹和文件

//BraveKnight.kt
interface Knight {
    fun embarkOnQuest()
}

class BraveKnight(private val quest: Quest): Knight {

    override fun embarkOnQuest() {
        quest.embark()
    }
}

//SlayDragonQuest.kt
interface Quest {
    fun embark()
}

class SlayDragonQuest(private val stream: PrintStream): Quest {

    override fun embark() {
        stream.println("Embarking on quest to slay the dragon!")
    }
}

//KnightConfig.kt
@Configuration
open class KnightConfig {

    @Bean
    open fun knight(): Knight = BraveKnight(quest())

    @Bean
    open fun quest(): Quest = SlayDragonQuest(System.out)
}

//KnightMain.kt
class KnightMain {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            val context: AnnotationConfigApplicationContext = AnnotationConfigApplicationContext(KnightConfig::class.java)
            //val context: ClassPathXmlApplicationContext = ClassPathXmlApplicationContext("knights.xml")   XML 方式配置
            val knight: Knight = context.getBean(Knight::class.java)
            knight.embarkOnQuest()
            context.close()
        }
    }
}

XML 的配置文件为

//knight.xml

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans.xsd">

  <bean id="knight" class="sia.knights.BraveKnight">
    <constructor-arg ref="quest" />
  bean>

  <bean id="quest" class="sia.knights.SlayDragonQuest">
    <constructor-arg value="#{T(System).out}" />
  bean>

beans>

输出结果为

Embarking on quest to slay the dragon!

面向切面编程

Aspect-Oriented Programming，AOP。DI 能够让相互协作的组件保持松耦合，而 AOP 则允许开发者把组件除自身核心功能之外，可重用的功能分离出来，比如日志、事务管理和安全等服务。AOP 思想中的相关术语包括

• Joinpoint：连接点，目标对象中所有可增强的方法
• Pointcut：切入点，目标对象中所有已增强的方法
• Advice：增强/通知，增强的代码
• Weaving：织入，将“通知”应用到切入点的过程
• Proxy：将“通知”织入到目标对象后，形成代理对象
• Aspect：切面，切入点+“通知”

使用一个传唱骑士事迹的吟游诗人服务类作为一个 AOP 的应用

//Minstrel.kt
open class Minstrel(private val stream: PrintStream) {
    open fun singBeforeQuest() {
        stream.println("Fa la la, the knight is so brave!")
    }

    open fun singAfterQuest() {
        stream.println("Tee hee hee, the brave knight did embark on a quest!")
    }
}

//knights.xml 加入以下代码
<bean id="minstrel" class="Minstrel">
    <constructor-arg value="#{T(System).out}" />
bean>

<aop:config>
<aop:aspect ref="minstrel">
<aop:pointcut id="embark" expression="execution(* *.embarkOnQuest(..))" />

<aop:before pointcut-ref="embark" method="singBeforeQuest" />

<aop:after pointcut-ref="embark" method="singAfterQuest" />
aop:aspect>
aop:config>

默认缺少 org.aspectj.aspectjweaver，可以引入 maven，添加对应的依赖

运行之后，控制台输出结果为

Fa la la, the knight is so brave!
Embarking on quest to slay the dragon!
Tee hee hee, the brave knight did embark on a quest!

不使用 BraveKnight 和 Minstrel 组合的方式而是使用 AOP，通过少量的 XML 配置，就可以把 Minstrel 声明为一个 Spring 切面，进而实现相应的功能。Minstrel 仍然只是一个 POJO，但可以被应用到任何需要它的地方，只需要修改配置文件中的 AspectJ 切点表达式语言即可。

装配 Bean

容器

Spring 容器（Container）负责创建、装配和配置对象，并且管理它们的生命周期。Spring 的核心便是容器，它自带多个容器实现，可以归为两种不同的类型：Bean 工厂（由org.springframework.beans.factory.BeanFactory接口定义）是最简单的容器，提供基本的 DI 支持；应用上下文（由org.springframework.context.ApplicationContext接口定义），基于 BeanFactory 构建，并提供应用框架级别的服务，例如从属性文本解析文本信息以及发送应用事件给感兴趣的事件监听者。重点在于应用上下文上。

Spring 自带多种应用上下文

• AnnotationConfigApplicationContext：从一个或多个基于 Java 的配置类中加载 Spring 应用上下文
• AnnotationConfigWebApplicationContext：从一个或多个基于 Java 的配置类中加载 Spring Web 应用上下文
• ClassPathXmlApplicationContext：从类路径下的一个或多个 XML 配置文件中加载上下文定义，把应用上下文的定义文件作为类资源
• FileSystemXmlApplicationContext：从文件系统的一个或多个 XML 配置文件中加载上下文定义
• XmlWebApplicationContext：从 Web 应用下的一个或多个 XML 配置文件中加载上下文定义

Bean 生命周期

1. Spring 对 bean 进行实例化
2. Spring 将值和 bean 的引用注入到 bean 对应的属性中
3. 如果 bean 实现了 BeanNameAware 接口，Spring 将 bean 的 ID 传递给setBeanName方法
4. 如果 bean 实现了 BeanFactoryAware 接口，Spring 将调用setBeanFactory方法，将 BeanFactory 容器实例传入
5. 如果 bean 实现了 ApplicationContextAware 接口， Spring 将调用setApplicationContext方法，将 bean 所在的应用上下文的引用传入
6. 如果 bean 实现了 BeanPostProcessor 接口，Spring 将调用它们的postProcessBeforeInitialization方法
7. 如果 bean 实现了 InitializingBean 接口，Spring 将调用它们的 afterPropertiesSet方法。类似的，如果 bean 使用 init-method 声明了初始化方法，该方法也会被调用
8. 如果 bean 实现了 BeanPostProcessor 接口，Spring 将调用它们的postProcessAfterInitialzation方法
9. 此时，bean 已经准备就绪，可以被应用程序使用了，它们将一直驻留在应用上下文中，直到该应用上下文被销毁
10. 如果 bean 实现了 DisposablBean 接口，Spring 将调用它的destroy接口方法。同样，如果 bean 使用 destroy-method 声明了销毁方法，该方法也会被调用

可选装配方案

有三种方式向 Spring 容器描述 Bean 如何装配

• 在 XML 文件中进行显示配置
• 在 Java 代码中进行显示配置
• 隐式的 bean 发现机制和自动装配

自动化装配 bean

Spring 从两个角度实现自动化装配

• 组件扫描（Component Scanning）：Spring 会自动发现应用上下文中所创建的 bean
• 自动装配（Autowiring）：Spring 自动满足 bean 之间的依赖

通过一个 CD 播放的 Demo 说明，XML config 文件位于/resources目录下，Kotlin 文件位于java/soundsystem目录下

//conpactDisc.kt
@Component
class CompactDisc {

    private val title = "Sgt. Pepper's Lonely Hearts Club Band"
    private val artist = "The Beatles"

    fun play() {
        println("Playing $title by $artist")
    }
}

//CDPlayer.kt
@Component
class CDPlayer @Autowired
constructor(private val cd: CompactDisc) {

    fun play() {
        cd.play()
    }
}

//CDPlayerTest.kt
@RunWith(SpringJUnit4ClassRunner::class)
@ContextConfiguration(classes = [CDPlayerConfig::class])
class CDPlayerTest {
    @Autowired
    lateinit var player: CDPlayer

    @Test
    fun play() {
        player.play()
    }
}

以上便是准备好的工程文件，使用@Autowired注解在需要自动装配的任何属性、构造器、方法上，然后在 Java 代码或者 XML 配置文件启动自动装配。不同的自动装配方式需要修改 JUnit 测试框架的@ContextConfiguration注解参数

• XML 方式：locations = ["classpath:spring-config.xml"]

• Java 方式：classes = [CDPlayerConfig::class]

JUnit 测试框架需要导入依赖

接下来的一步便是启用 Spring 的组件扫描，也就是配置以上的两种注解参数之一，搭配 Bean 类注解@Component便可以实现组件扫描。以下两种做法都可以，第一种是使用一个Config类并添加注解@Configuration和@ConponentScan，第二种则是在 XML 文件中配置context:component-scan

//Java 代码
@Configuration
@ComponentScan
open class CDPlayerConfig

//XML 文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="soundsystem" />

beans>

运行测试，控制台成功输出

Playing Sgt. Pepper's Lonely Hearts Club Band by The Beatles

Java 代码装配

大多数情况下都可以通过自动化装配的方式完成配置，但是当我们使用第三方的类库组件时，无法在组件类上直接添加注解，只能使用显示装配。这种情况下，使用 JavaConfig 是最好的方式。通常将 JavaConfig 放到同一个包中，并且它应该不包含任何的业务逻辑。

@Configuration
open class CDPlayerConfig {
    
    @Bean
    open fun sgtPeppers(): SgtPeppers = SgtPeppers()
    
    @Bean
    open fun cdPlayer(): CDPlayer = CDPlayer(sgtPeppers())
    
    @Bean
    open fun anotherCDPlayer(): CDPlayer = CDPlayer(sgtPeppers())
    
    @Bean
    open fun cdPlayerUseParam(compactDisc: CompactDisc): CDPlayer {
        val cdPlayer = CDPlayer(compactDisc)
        cdPlayer.setCompactDisc(compactDisc)
        return cdPlayer
    }
}

在上面的代码中，配置类CDPlayerConfig中提供了几种装配 Bean 的方式。sgtPeppers方法注入了一个 SgtPeppers 实例，cdPlayer和anotherCDPlayer需要调用该方法来注入 CDPlayer 实例。Spring 会拦截所有对该方法的调用，并直接返回该方法创建的 Bean，并且默认情况下 Bean 是单例的。

最后一个方法则展现了一个更具可读性、更多样化的注入方式。

XML 代码装配

最简单的 Spring XML 配置如下

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
beans>

需要在配置文件顶部声明多个 XML 模式（XSD）文件，这些文件定义了配置 Spring 的 XML 元素。配置文件的根元素。

声明一个简单的 Bean 可以通过下面的方式实现

<bean id="cdPlayer" class="sound_system.CDPlayer">
<constructor-arg ref="sgtPeppers"/>
bean>
    
<bean id="sgtPeppers" class="sound_system.SgtPeppers" />

如果没有指定 id，该 Bean 将会根据全限定类名命名：sound_system.CDPlayer#0，#0为计数形式，用以区分相同类型的其他 Bean。

<constructor-arg>元素告知 Spring 要将一个 id 为sgtPeppers的 bean 引用传递到 CDPlayer 的构造器中。作为替代，也可以使用 Spring 的 c-命名空间，不再赘述。关于<constructor-arg>元素的更多知识：IOC 之解析 bean 标签：constructor-arg、property 子元素

在该元素中，可以使用value属性将字面量传递给构造器，使用子元素<null/>空值，使用子元素<list>传递集合。

XML 配置也提供了设置属性的接口，通过元素property可以将对象引用、字面量、集合等注入 Bean 中。比如为 SgtPeppers 添加新的属性并对外提供修改接口

class SgtPeppers: CompactDisc {
    var title = "Sgt. Pepper's Lonely Hearts Club Band"
    var artist = "The Beatles"
    var tracks: MutableList = ArrayList()
    
    override fun play() {
        println("Playing $title by $artist")
    }
}

然后在 XML 文件中注入属性设置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="sgtPeppers" class="sound_system.SgtPeppers">
        <property name="title" value="new title" />
        <property name="artist" value="new artist" />
        <property name="tracks">
            <list>
                <value>track 1value>
                <value>track 2value>
                <value>track 3value>
                <value>track 4value>
            list>
        property>
    bean>

beans>

导入和混合配置

当开发者使用自动装配的时候，Spring 会考虑容器中的所有 Bean，因此不用考虑混合配置的问题。混合配置应用在显式装配时，比如 XML 和 Java 互相引用配置的 Bean。

在 JavaConfig 中使用注解@Import导入其他 JavaConfig，使用注解@ImportResource混合 XML 配置，比如

@Configuration
@Import(CDPlayerConfig::class)
@ImportResource("classpath:sound_system.xml")
open class SoundSystemConfig

在 XML 中使用元素import导入其他 XML 文件，而如果要导入 JavaConfig，做法很简单 ：将其声明为一个 bean 即可。

入门

搭建环境

确保系统已安装 JDK 1.7及以上，此处将介绍 Gradle 在 Windows 平台下的手动安装。在 https://gradle.org/releases/ 下载最新的 release 包并解压至相应文件夹，然后在系统环境变量添加GRADLE_HOME，作者的变量值为D:\gradle-5.4.1，最后再将%GRADLE_HOME%\bin添加进Path变量中即可。在命令行中键入gradle -v验证环境搭建结果。

PS C:\Users\Febers> gradle -v

Welcome to Gradle 5.4.1!

Here are the highlights of this release:
 - Run builds with JDK12
 - New API for Incremental Tasks
 - Updates to native projects, including Swift 5 support

For more details see https://docs.gradle.org/5.4.1/release-notes.html

Hello World

新建一个工程项目，比如gradle_demo，然后新建一个build.gradle文件，在其中输入

task hello {
  doLast {
    println 'Hello World!'
  }
}

在当前文件夹命令行中键入gradle -q hello即可输出Hello World!。这里使用的是基于 Groovy 的 DSL（Domain Specific Language，领域特定语言）。

task 和 action 是 Gradle 的重要元素，前者代表一个独立的原子操作，比如复制一个文件、编译一次 Java 代码，这里简单定义一个名为hello的 task；后者则是前者的组成部分，doLast代表 task 执行的最后一个 action，task 执行完毕之后会回调该 action。

日志级别

和 Android 类似，Gradle 也定义了日志级别

上文运行任务所使用到的命令gradle -q hello中的-q即为日志的级别开关选项

Project

每个 Gradle 项目都由一个或多个 Project 构成，每个 Project 又都由 Task 构成。一个 build.gradle文件便是对一个 Project 对象的配置。在 Android 项目中，根目录会存在一个build.gradle文件，每个模块下也会有一个该文件。

在构建脚本中调用的没有在构建脚本中定义的方法和属性都委派给 Project 对象，比如project.copy()等价于copy()、project.buildDir等价于buildDir

Task

创建任务

task hello {
  doLast {
    println 'Hello World!'
  }
}

//直接用任务名称
def Task helloo = task(helloo)
helloo.doLast {
  println 'Helloo World!'
}

//声明任务配置
def Task hellooo = task(hellooo, group: BasePlugin.BUILD_GROUP)
hellooo.doLast {
  println 'Hellooo World!'
}

//使用 TaskContainer 的 create 方法创建，以上三种方式最终都会调用该方法
tasks.create(name: 'helloooo') {
  doLast {
    println 'helloooo World!'
  }
}

输入gradle -q hello*之后的结果为，说明成功创建任务

Hello World!
Helloo World!
Hellooo World!
helloooo World!

任务顺序

通过dependsOn指定任务的依赖，通过一个例子理解

task hello {
  println 'hello'
    
  doFirst {
    println 'hello first'
  }
  doLast {
    println 'Hello last'
  }
}

task go(dependsOn: hello) {
  println 'go'

  doLast {
    println 'go last 0'
  } 

  doFirst {
    println 'go first'
  }

  doLast {
    println 'go last 1'
  }
}

输入gradle -q go之后的输出结果为

hello
go
hello first
Hello last
go first
go last 0
go last 1

排除任务

在命令行后添加-x go来排除任务 go，输入gradle hello -x go之后

> Task :hello
hello
hello first
hello last

BUILD SUCCESSFUL in 1s
1 actionable task: 1 executed

动态任务

可以通过拓展方法times动态创建任务

3.times {
  count -> task "task$count" {
    doLast {
      println "task $count"
    }
  }
}

输入gradle -q task0之后将输出task 0，已创建的三个任务中的一个

任务属性

标准属性有group、description等，除此之外的自定义属性需添加ext前缀

task hello {
  group = 'group0'
  description = 'description'
  ext.myTitle = 'title'
  ext.myId = 9527

  doLast {
    println "任务分组属性: $group"
    println "任务描述:属性 $description"
    println "自定义Title属性: $myTitle"
    println "自定义Id属性: $myId"
  }
}

输出正常

Groovy

Gadle 使用 Groovy 的 DSL 编写，Groovy 是 Apache 推出的 JVM 语言。Groovy 的学习可以参考其官方文档，写得相当友好。Groovy 可以与 Java 无缝连接，甚至可以在其中直接使用 Java 语法，Java 中调用 Groovy 也相当方便。此处只介绍一些与 Java 不同的地方。

Groovy 会默认导入以下包，不需要显示导入

java.io.*
java.lang.*
java.math.BigDecimal
java.math.BigInteger
java.net.*
java.util.*
groovy.lang.*
groovy.util.*

可以导入 SDK 之后在 IDE 中编写 Groovy 程序，也可以在 build.gradle 中编写代码，在 task

中调用，使用 gradle 命令运行。以下的例子采用后一种方法。

变量与方法

使用 def 关键字来定义变量和方法，可以不指定变量的类型，默认访问修饰符为 public。Groovy 中使用双引号定义字符串的时候类型为GString而非java.lang.String，因此可以使用$输出表达式结果

task t {
  //定义变量，可以使用 def，也可以使用具体类型，或者两者结合
  def a = 0
  def int b = 1

  //定义字符串，同 dart 
  String s = "s"
  String ss = 'ss'
  String sss = """first row
  second row"""

  println "95-27=${minus(95,27)}"
  println "95+27=${add 95,27}"
}

//指定返回类型则 def 可省略，且参数类型可省略
//不使用 return 则返回最后一行
int minus(a, b) {
  println "before return"
  a - b
}

//定义方法
def add(int a, int b) {
  return a + b
}

控制台输出

before return
95-27=68
95+27=122

对象

Groovy 中的类与 Java 类似，不过由于没有访问修饰符，默认为public，要想实现 Java 默认的包访问权限（default），可以使用注解@PackageScope。对于没有可见性修饰的变量，Groovy 会隐式提供setter/getter方法。以下的两个类是等价的

task t {
  def object = new ClassInGroovy()
  object.name = "Jack"
  println "${object.name}"
}

public class ClassInJava {
  public String name;

  public String getName() {
    return name;
  }

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

class ClassInGroovy {
  String name
}

此外 Groovy 使用asType函数进行类型转换，支持object.with{ }进行级联操作，支持使用?.进行非空操作，都是些很眼熟的语法特性

闭包

闭包在 Groovy 中是groovy.lang.Closure的实例，类似于 Dart 中的函数是 Function 的实例，因此可以像变量一样传递，其语法定义为

//闭包的参数为可选项
def closure = { [closureParameters -> ] statements }

闭包跟函数不同的地方在于其可以访问外部变量

task t {
  def str = "hello"
  def closure0 = {
    println str  
  }

  def closure1 = { String name, int t -> 
    println "before print"
    println "$name call $t times"
  }

  //调用，call 可省略
  closure0.call()
  closure1("Jack", 10)
}

与 Java 中的 Lambda 表达式类似，闭包可以当做参数传递，当闭包为最后一个参数时可写在调用的括号后

文件读取

相较于 Java，Groovy 的文件读写非常简洁友好。在当前文件夹新建一个文件静夜思.txt

task t {
  def path = "静夜思.txt"
  def file = new File(path).eachLine { line ->
    println line
  }
  //更简洁
  println file.text

  //写入，该方法会打印并覆盖原来的内容
  file.withPrintWriter {
    it.println "表达了诗人对家乡的思念"
  }
}

其他

Groovy 中的流程控制语句（比如if/else、for/in、switch/case）、数据结构（比如List、Map）与 Java/Dart 类似，在此便不过多费笔墨，参考官方文档即可。

Gradle Wrapper

Gradle 包装器。为了应对团队开发中 Gradle 环境和版本的差异会对编译结果带来的不确定性，使用 Gradle Wrapper，它是一个脚本，可以指定构建版本、快速运行项目，从而达到标准化、提到开发效率。Android Studio 新建项目时自带 Gradle Wrapper，因此 Android 开发者很少单独下载安装 Gradle

Gradle Wrapper 的工作流程如下图

使用 Gradle Wrapper 启动 Gradle 之后，如果指定版本的 Gradle 没有被下载关联，会先从官方仓库下载到用户本地，进行解包并执行批处理文件。后续的构建运行都会重用这个解包的运行时安装程序

构建 Gradle Wrapper

Gradle 内置 Wrapper Task，执行 Wrapper Task 就可以在项目目录中生成对应的目录文件。在项目根目录执行gradle wrapper 命令即可。之后根目录的文件结构如下

├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
└── gradlew.bat

文件含义为

• gradle-wrapper.jar ：包含 Gradle 运行时的逻辑代码。
• gradle-wrapper.properties ：负责配置包装器运行时行为的属性文件
• gradlew：Linux 平台下，用于执行 Gralde 命令的包装器脚本。
• gradlew.bat：Windows 平台下，用于执行 Gradle 命令的包装器脚本。

查看.properties文件

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

属性含义为

• distributionBase：Gradle 解包后存储的主目录。
• distributionPath：distributionBase 指定目录的子目录。distributionBase+distributionPath 为 Gradle 解包后的存放位置。
• distributionUrl：Gradle 发行版压缩包的下载地址。
• zipStoreBase：Gradle 压缩包存储主目录。
• zipStorePath：zipStoreBase 指定目录的子目录。zipStoreBase+zipStorePath 为 Gradle 压缩包的存放位置。

如果官方包发行版下载缓慢，可以手动更改distributionUrl为可用地址

使用 Gradle Wrapper

使用gradlew.bar代替gradle运行 Gradle Project，首次使用会下载 Gradle 到配置文件指定的位置，作者的路径为C:\Users\23033\.gradle\wrapper\dists\gradle-5.4.1-bin\e75iq110yv9r9wt1a6619x2xm\gradle-5.4.1

PS D:\Work\Gradle\gradle_demo> .\gradlew.bat t
Downloading https://services.gradle.org/distributions/gradle-5.4.1-bin.zip
...................................................................................

Hello World!

再次使用该命令便不会重复下载。升级 Gradle 版本可以通过gradlew wrapper –gradle-version 5.*.*命令实现

Gradle 插件

Gradle 中的插件可分为两类

• 脚本插件：额外的构建脚本，类似于一个 build.gradle
• 对象插件：又叫二进制插件，是实现了 Plugin 接口的类

应用插件又分为两个步骤，一是解析插件，二是通过apply()把插件应用到项目中。

脚本插件

在根目录新建一个other.gradle文件，内容如下

ext {
  otherVersion = '1.0'
  otherUrl = 'https://febers.github.io'
}

将build.gradle内容修改为

apply from: 'other.gradle'
task t {
  println "版本为: ${otherVersion},地址为: ${otherUrl}"
}

输出结果

PS D:\Work\Gradle\gradle_demo> .\gradlew.bat t

> Configure project :
版本为: 1.0,地址为: https://febers.github.io

对象插件

对象插件是实现了org.gradle.api.plugin接口的插件，又可分为内部插件和第三方插件

内部插件

使用以下方法应用 Java 插件（因为默认导入org.gradle.api.plugin包，所以可以去掉包名）

apply plugin: org.gradle.api.plugins.JavaPlugin
apply plugin: JavaPlugin//去掉包名
apply plugin: 'java'//使用 pluginid（实现 plugin 接口的插件的属性）
apply plugin: 'cpp'    //Gradle 中含有大量插件

第三方插件

一般为 jar 文件，通过buildscript配置，此处引入 Android Gradle 插件

buildscript {
  repositories {
    google()
  }
  dependencies {
    classpath 'com.android.tools.build:gradle:3.4.1'
  }
}
apply plugin: 'com.android.application'

如果第三方插件被托管到 Gradle - Plugins，也可以不使用buildscript

plugins {
  id "com.quittle.setup-android-sdk" version "1.2.0"
}

自定义对象插件

Plugin 接口中定义了一个apply方法，重写该方法，在其中通过传进来的参数Object o（实际为 Project 类型）调用 task 新建一个任务

class MyPlugin implements Plugin {
  @Override
  void apply(Object o) {
    o.task("myTask") {
      println "This is a custom task in custom plugin"
    }
  }
}
apply plugin: MyPlugin

输入命令gradle myTask即可验证

Android 中的 Gradle

为了支持 Android 项目的构建，Google 为 Gradle 编写了 Android 插件，组成 Android 构建系统。Android Studio+Gradle 是目前最流行的 Android 开发构建环境。关于 Android 构建配置可查阅官方文档 配置构建

模块类型

Android Studio 中的每个项目包含一个或多个含有源代码文件和资源文件的模块，这些模块可以独立构建测试，模块类型包含以下几种

• Android 应用程序模块：可能依赖于库模块，构建系统会将其生成一个 apk 文件
• Android 库模块：包含可重用的特定于 Android 的代码和资源，构建系统将其生成一个 aar 文件
• App 引擎模块：包含应用程序引擎继承的代码和资源
• Java 库模块：包含可重用的代码，构建系统将其生成一个 jar 文件

项目结构

在 Android Studio 中，Android 项目视图如下，以开发者个人项目 UESTC_BBS 为例

所有构建稳健位于 Gradle Scripts 层级下，文件作用如下

• 项目 build.gradle：配置项目整体属性，比如指定的代码仓库、依赖的 Gradle 版本等
• 模块 build.gradle：配置当前模块的编译参数
• gradle-wrapper-properties：配置 Gradle Wrapper
• gradle-properties：配置 Gradle
• setting.gradle：配置 Gradle 的多项目管理
• local.properties：存放 Android 项目的私有属性配置，如 SDK 路径
• multiDexKeep.pro、proguard-rules.pro：可选的混淆文件，用于配置放置在主 Dex 的类、声明避免混淆的类

项目 build.gradle

典型的项目build.gradle文件如下

buildscript {
    ext.kotlin_version = '1.3.10'
    repositories {
        mavenCentral()
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.4.0'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version"
    }
}

allprojects {
    repositories {
        google()
        jcenter()
        mavenCentral()
        maven { url 'https://jitpack.io' }
        maven { url "https://maven.google.com" }
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

其中google()是配置 Google 的 Maven 仓库，maven { url "https://maven.google.com" }同理

模块 build.gradle

典型的模块build.gradle文件如下

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'kotlin-kapt'
ext.anko_version = '0.10.5'

dependencies {
    implementation fileTree(include: ['*.jar'], dir: 'libs')
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
    implementation 'com.android.support:multidex:1.0.3'
    implementation 'androidx.appcompat:appcompat:1.0.2'
    testImplementation 'junit:junit:4.12'
}

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "com.febers.uestc_bbs"
        minSdkVersion 17
        targetSdkVersion 28
        versionCode 12
        versionName "1.1.4"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        multiDexEnabled true
        multiDexKeepProguard file('multiDexKeep.pro') // keep specific classes using proguard syntax
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

第一行 apply 的是一个application，说明当前模块为一个应用程序模块，Gradle 的 Android 插件分为以下几种

• 应用程序插件：插件 id 为com.android.application，构建生成 apk
• 库插件：插件 id 为com.android.library，构建生成 aar
• 测试插件：插件 id 为com.android.test，用于测试其他模块
• feature 插件：插件 id 为com.android.feature，用于创建 Android Instant App
• instant App 插件：插件 id 为com.android.instantapp，是 Android Instant App 的入口

很多属性都可以望文生义，此处不再赘述。

参考

Gradle的Android插件入门

Gradle核心思想

委托

基本使用

定义一个委托属性的基本语法为 val/var <属性名>: <类型> by <表达式>，在 by 后面的表达式即为委托， 属性对应的 get()与set()会被委托给它的 getValue() 与 setValue() 方法。

class Example {
    var p: String by Delegate()

    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            var e = Example()
            println(e.p)
            e.p = "newValue"
        }
    }
}

class Delegate {

    operator fun getValue(thisRef: Any?, property: Any): String {
        return "$thisRef, thank you for delegating '$property' to me!"
    }

    operator fun setValue(thisRef: Any?, property: Any, value: String) {
        println("$value has been assigned to '$property' in $thisRef.")
    }
}

上述代码中，Delegate 内方法的参数 property 原本为 KProperty<*> 接口类型，为了手动调用其方法，改成 Any 以实现传参。

控制台输出结果为

Example@1175e2db, thank you for delegating 'p' to me!
newValue has been assigned to 'p' in Example@1175e2db.

可以看到属性 p 委托给了 Delegate() 对象实例，按照约定，该对象必须声明具有getValue、setValue方法，且方法参数个数必须大于2、3。

为了更清楚的了解这一过程，可以将代码改写成另一种形式

class Example {

    var delegate: Delegate = Delegate()
    
    var p: String
        set(value) {
            delegate.setValue(thisRef = this, property = delegate, value = value)
        }
        get() = delegate.getValue(thisRef = this, property = delegate)
}

当我们使用 p 时调用其get方法，给 p 赋值时调用其set方法，并且都是通过委托对象 delegate 实现。

标准委托

lazy

函数lazy接收一个 lambda 表达式并返回一个 Lazy 实例，默认情况下其线程安全

//方法签名
public actual fun  lazy(initializer: () -> T): Lazy = SynchronizedLazyImpl(initializer)


val s: String by lazy {
println("get")
"hello"
}

println(s)
println(s)

只有在第一次调用 s 时才会执行传递给 lazy() 的 lambda 表达式并返回一个记录下来的结果， 后续调用 get() 只会返回记录的结果。底层原理在于函数签名中的SynchronizedLazyImpl方法，其中会检查变量的值，判断其是否为默认值，如果是则执行初始化函数，否则直接返回结果，具体代码可以查阅LazyJVM.kt文件。

控制台输出为

get
hello
hello

observable

字面意思，用委托的方式来定义一个可观察属性。该函数的方法签名为

public inline fun  observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit):
            ReadWriteProperty

其接收两个参数，第一个为默认值，第二个为 lambda 表达式，位于Delegates.kt，具体使用

var name: String by Delegates.observable("initialValue") {
property, oldValue, newValue ->
println("$oldValue -> $newValue")
}
name = "newValue0"
name = "newValue1"

控制台输出

initialValue -> newValue0
newValue0 -> newValue1

Storing

将对象的属性委托值 map 中，用于解析 JSON 或者其他动态工作，不过应用较少

val user = User(mapOf("name" to "Jack", "age" to 20))
println(user.name)
println(user.age)

class User(private val map: Map) {
    val name: String by map
    val age: Int by map
}

典型应用

封装一个 SharedPreferences（简称 SP） 是 Android 开发中经常要做的事，因为直接调用 SP 足够繁琐。如果是 Java 代码，则代码基本如下

public final class PreferencesUtil {
    private static PreferencesUtil sInstance;

    public static void init(Context context) {
        if (sInstance == null) {
            sInstance = new PreferencesUtil(context);
        }
    }

    public static PreferencesUtil getInstance() {
        if (sInstance == null) throw new RuntimeException("Uninitialized.");

        return sInstance;
    }

    private final SharedPreferences mSp;

    private PreferencesUtil(Context context) {
        mSp = PreferenceManager.getDefaultSharedPreferences(context);
    }

    public String getString(String key, String defValue) {
        return mSp.getString(key, defValue);
    }

    public void putString(String key, String value) {
        mSp.edit().putString(key, value).apply();
    }

    public int getInt(String key, int defValue) {
        return mSp.getInt(key, defValue);
    }

    public void putInt(String key, int value) {
        mSp.edit().putInt(key, value).apply();
    }

    public long getLong(String key, long defValue) {
        return mSp.getLong(key, defValue);
    }

    public void putLong(String key, long value) {
        mSp.edit().putLong(key, value).apply();
    }

    public float getFloat(String key, float defValue) {
        return mSp.getFloat(key, defValue);
    }

    public void putFloat(String key, float value) {
        mSp.edit().putFloat(key, value).apply();
    }

    public boolean getBoolean(String key, boolean defValue) {
        return mSp.getBoolean(key, defValue);
    }

    public void putBoolean(String key, boolean value) {
        mSp.edit().putBoolean(key, value).apply();
    }
}

外部调用

if (PreferencesUtil.getInstance().getBoolean(Constant.IS_FIRST_LAUNCH, Constant.DEF_IS_FIRST_LAUNCH)) {
    // Do something first launch, like showing Welcome.
    ...

    PreferencesUtil.getInstance().putBoolean(Constant.IS_FIRST_LAUNCH, false);
}

使用 Kotlin 的委托属性之后实现就简洁很多

class PreferenceUtils<T>(val context: Context, val name: String, val default: T): ReadWriteProperty {

    val prefs: SharedPreferences by lazy { context.defaultSharedPreferences }

    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return findPreference(name, default)
    }

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        putPreference(name, value)
    }

    private fun  findPreference(name: String, default: T): T = with(prefs) {
        val res: Any = when (default) {
            is Long -> getLong(name, default)
            is Int -> getInt(name, default)
            is String -> getString(name, default)
            is Boolean -> getBoolean(name, default)
            is Float -> getFloat(name, default)
            else -> throw IllegalArgumentException("This type can't be saved into Preferences")
        }
        return@with res as T
    }

    private fun  putPreference(name: String, value: T) = with(prefs.edit()) {
        when (value) {
            is Long -> putLong(name, value)
            is Int -> putInt(name, value)
            is String -> putString(name, value)
            is Boolean -> putBoolean(name, value)
            is Float -> putFloat(name, value)
            else -> throw IllegalArgumentException("This type can't be saved into Preferences")
        }.apply()
    }
}

其中接口ReadWriteProperty为系统提供的规范接口，其中定义了getValue/setValue方法。外部调用如下

var themeCode by PreferenceUtils(context, Constant.theme_code, default = 1)
themeCode = 9527

Mirror

Example

main() {
    ClassMirror cm = reflectClass(ChildClass);
    cm.instanceMembers.forEach((key, value) => print('$key >>> $value'));
    
    ClassMirror simpleCM = reflectClass(Simple);
    Simple simple = simpleCM.newInstance(Symbol.empty, ['hey']) as Simple;
}

class Simple {
  Simple(a) {
    print('A new Simple: $a');
  }
}

class SuperClass {
  int superField = 0;
  final int superFinalField = 1;
  int get superGetter => 2;
  set superSetter(x){ superField = x; }
  int superMethod(x) => 4;

  static int superStaticField = 5;
  static final int superStaticFinalField = 6;
  static const superStaticConstField = 7;
  static int get superStaticGetter => 8;
  static set superStaticSetter(x) { }
  static int superStaticMethod(x) => 10;
}

class ChildClass extends SuperClass {
  int aField = 11;
  final int aFinalField = 12;
  get aGetter => 13;
  set aSetter(x) { aField = x; }
  int aMethod(x) => 15;

  static int staticField = 16;
  static final staticFinalField = 17;
  static const staticConstField = 18;
  static int get staticGetter => 19;
  static set staticSetter(x) { staticField = x; }
  static int staticMethod(x) => 21;
}

控制台输出为

Symbol("==") >>> MethodMirror on '=='
Symbol("hashCode") >>> MethodMirror on 'hashCode'
Symbol("toString") >>> MethodMirror on 'toString'
Symbol("noSuchMethod") >>> MethodMirror on 'noSuchMethod'
Symbol("runtimeType") >>> MethodMirror on 'runtimeType'
Symbol("superField") >>> Instance of '_SyntheticAccessor'
Symbol("superField=") >>> Instance of '_SyntheticAccessor'
Symbol("superFinalField") >>> Instance of '_SyntheticAccessor'
Symbol("superGetter") >>> MethodMirror on 'superGetter'
Symbol("superSetter=") >>> MethodMirror on 'superSetter='
Symbol("superMethod") >>> MethodMirror on 'superMethod'
Symbol("aField") >>> Instance of '_SyntheticAccessor'
Symbol("aField=") >>> Instance of '_SyntheticAccessor'
Symbol("aFinalField") >>> Instance of '_SyntheticAccessor'
Symbol("aGetter") >>> MethodMirror on 'aGetter'
Symbol("aSetter=") >>> MethodMirror on 'aSetter='
Symbol("aMethod") >>> MethodMirror on 'aMethod'
A new Simple: hey

分类

在官方 API 页面可以看到所有的 Mirror 类型：dart:mirrors library。Mirror 的主要类型如下

• ClassMirror：Dart 类的反射类型

• InstanceMirror：Dart 实例的反射类型

• ClosureMirror： 闭包的反射类型

• DeclarationMirror：类属性的反射类型

• IsolateMirror：Isolate 的反射类型

• MethodMirror：Dart 方法（包括函数、构造函数、getter/setter 函数）的反射类型

通过dart:mirrors包内顶层函数reflecClass 获得类的“镜像”的实例，该实例的instanceMembers属性如下

Map<Symbol, MethodMirror> get instanceMembers;

由控制台输出结果可以看到，对于普通字段（属性），除自身外还列出了以“=”结尾的 setter 字段，对于不提供 setter 的final字段则只出现一次。

使用staticMembers将列出所有的静态字段

cm.staticMembers.forEach((key, value) => print('$key >>> $value'));

输出如下

Symbol("staticField") >>> Instance of '_SyntheticAccessor'
Symbol("staticField=") >>> Instance of '_SyntheticAccessor'
Symbol("staticFinalField") >>> Instance of '_SyntheticAccessor'
Symbol("staticConstField") >>> Instance of '_SyntheticAccessor'
Symbol("staticGetter") >>> MethodMirror on 'staticGetter'
Symbol("staticSetter=") >>> MethodMirror on 'staticSetter='
Symbol("staticMethod") >>> MethodMirror on 'staticMethod'

可以发现父类静态成员没有出现在列表中，这是因为静态属性不会被继承、不能被ChildClass调用。

Symbol

Symbol表示使用 Dart 的 mirror API 反射得到的实例类型，位于dart:core包

part of dart.core;

/// Opaque name used by mirrors, invocations and [Function.apply].
abstract class Symbol {

  static const Symbol unaryMinus = const Symbol("unary-");

  static const Symbol empty = const Symbol("");

  //工厂构造方法
  //也可以直接通过 Symbol s = #name; 创建
  const factory Symbol(String name) = internal.Symbol;

  int get hashCode;
  
  bool operator ==(other);
}

源码

通过 ClassMirror 的源码，可以大概看出 Dart 语言关于反射的设计思想以及对外提供的 API

abstract class ClassMirror implements TypeMirror, ObjectMirror {

  ClassMirror get superclass;//父类 ， Object的父类为null

  List get superinterfaces;//接口列表

  bool get isAbstract;

  bool get isEnum;

  Map<Symbol, DeclarationMirror> get declarations;//不包含父类属性和方法

  Map<Symbol, MethodMirror> get instanceMembers;//实例属性

  Map<Symbol, MethodMirror> get staticMembers;//静态属性

  //如果S = A with B ,那么ClassMirror（S）.mixin 为 ClassMirror（B），否则返回本身
  ClassMirror get mixin;
    
  /**
   * 调用构造方法
   * @param constructorName 构造方法名称（默认构造方法为空字符串，命名构造方法为其命名）
   * @param positionalArguments 参数列表
   */
  InstanceMirror newInstance(Symbol constructorName, List positionalArguments,
      [Map<Symbol, dynamic> namedArguments]);

  bool operator ==(other);

  bool isSubclassOf(ClassMirror other);
}

影响

在 Java 中，当开发者多次（10w 次以上）访问、修改某一属性时，使用反射的成本会比正常访问高很多，同时会让private修饰符失去作用。在 Dart 中，反射的影响主要在于，编译器使用tree shaking的过程确定应用真正运行时使用的代码，以减少程序的大小。但是使用反射将使tree shaking失效，因为任何代码都有可能被使用，由此严重影响应用的启动时间和内存占用。

解决👆一问题的有效方法是，通过代码生成执行反射。为了“告知”编译器使用反射的代码和方式，开发者可以使用dart:reflectable库，通过特定元数据注解反射代码。reflectable

另一个影响在于最小化，其表示对下载到 Web 浏览器的源程序进行压缩的过程。在最小化过程中，源代码使用的名称在编译代码中被压缩成了短名称。这一过程会对反射带来不良影响，因为最小化之后，原来表示声明的名称的字符串，不再对应程序中的实际名称。

为了解决这一问题， Dart 反射使用 symbol 而非字符串作为 key，symbol 会被执行最小化的程序minifier识别并使用与标识符同样的压缩方式。这也是上面的输出中出现Symbol(...)的原因。开发者也可以通过 MirrorSystem 提供的static String getName(Symbol symbol)方法获得非最小化名称字符串。

小结

目前来看 Dart 还不算一门“足够完善”的语言，比如反射机制的不完全、文档教程匮乏等等，相信随着 Flutter 的发展，这门语言的发展会更加地好。关于 Dart 反射的知识全部来自 Gilad Bracha 所著《Dart 编程语言》，不知道是不是翻译的问题，写得不够明晰，看得也是一头雾水。希望有朝一日，更加掌握 Dart 的反射机制，再写一篇《Dart 反射机制详解》的文章 😄。

关于

Markdown 是一门轻量级的标记语言，由美国工程师 John Gruber 于2004年创造。这门语言的目的是让人们使用易于阅读、易于撰写的纯文字格式，并选择性地转换成有效的 XHTML（或是 HTML）。

Markdown 所谓的易读并不是指排版之后呈现的结果易读，而是指原始格式下的文件依然拥有优秀的可读性，不会像阅读原始 HTML 代码一样，满眼都是尖括号（可以通过 右键浏览器页面 -> 查看源代码 体验）。Markdown 的易写则体现在其语法足够简单，学习曲线平缓，并且在写作中基本可以脱离鼠标操作。

Markdown 的轻量级是相对于 LaTeX 来说的，这种基于 Tex 的排版系统广泛运用在高质量书籍印刷和复杂公式论文中。不过使用 Markdown 仍然可以使用一些基本的数学公式，比如$ E = mc^2 $、$ \int_0^xf(x)dx $，单个$用于行内公式，$$用于单行公式

比如 $ E = mc^2 $、$ \int_0^xf(x)dx $

这需要不同平台上的 Markdown 数学公式插件的支持，本博客使用Hexo + Github Pages搭建，可以通过安装 MathJax 实现。

分类

跟早期的 HTML 类似，Markdown 在发展的过程中衍生出了不同的版本，它们的基本语法上相通，但是在诸如表格、锚点、时序图等实现上出现了不一致。在关于语法规范化的讨论中，作者 John Gruber 认为，不同的网站（和人们）有不同的需求，没有一种语法可以让所有人满意。

现今 Markdown 的主要分类如下

• CommonMark：由 Stack Exchange、Github、Reddit 等组织发起的标准化项目。一开始名称为Standard Markdown，由于遭到作者的反对，更名CommonMark
• GFM：Github Flavored Markdown，由 Github 于2017年发布，基于 CommonMark。相信很多开发者都是通过一份README.md文件认识 Markdown，这也是本博客采用的版本。
• Markdown Extra：基于 PHP、Python 和 Rudy 中实现的 Markdown。

编辑器

市面上优秀的 Markdown 编辑器层出不穷，这也有力推动了 Markdown 的发展。可以使用Sublime Text配合插件编辑写作，可以使用Typora等优秀的跨平台工具实现所见即所得，也可以通过 Cmd Markdown 在线书写并导出、发布。

博主使用的是Typora。

相关链接：码字必备：18 款优秀的 Markdown 写作工具 | 2015 年度盘点、 用 Markdown 写作用什么文本编辑器？ - 知乎

初级语法

标题

# 一级标题
## 二级标题
### 三级标题
#### 四级标题
##### 五级标题
###### 六级标题