宋德凌

Git | Git分支管理-Git Flow

Sat, 21 Dec 2019 00:00:00 +0000

Git分支管理-Git Flow

一、什么是Git Flow

1、为什么要有分支管理

大部分开发人员现在使用Git就只是用三个，两个分支，一个是Master, 一个是Develop, 还有一个是基于Develop打得各种分支，甚至有的团队就一个Master分支。这个在小项目规模的时候还勉强可以支撑，因为很多人做项目就只有一个Release, 但是人员一多，而且项目周期一长就会出现各种问题。就像代码需要代码规范一样，代码管理同样需要一个清晰的流程和规范。

2、什么是Git Flow

Vincent Driessen曾经写过一篇博文，题为“A successful Git branching model“（一个成功的Git分支模型）。Gitflow工作流程就是从这篇文章里来的。下面是Git Flow的流程图

Git Flow流程图

Gitflow工作流程围绕项目发布定义了严格的分支模型。尽管它比Feature Branch Workflow更复杂一些，但它也为管理更大规模的项目提供了坚实的框架。

###3.Git Flow常用的分支

用于记录历史的分支：Master和develop

分支命题

Master：版本（标签/tag）号

develop：develop/迭代周期

Gitflow使用两个分支来记录项目开发的历史，而不是使用单一的master分支。在Gitflow流程中，master只是用于保存官方的发布历史，而develop分支才是用于集成各种功能开发的分支。使用版本号为master上的所有提交打版本（标签/tag）。

Master和develop
用于功能开发的分支：Feature

分支命名

Feature：reature/taskName(任务/功能名)

每一个新功能的开发都应该各自使用独立的分支。为了备份或便于团队之间的合作，这种分支也可以被推送到中央仓库。但是，在创建新的功能开发分支时，父分支应该选择develop（而不是master）。当功能开发完成时，改动的代码应该被合并（merge）到develop分支。功能开发永远不应该直接牵扯到master。

Feature
用于发布的分支：Release

分支命名

Release：release/版本（标签/tag）号

一旦develop分支积聚了足够多的新功能（或者预定的发布日期临近了），你可以基于develop分支建立一个用于产品发布的分支。建立Release分支后，我们只能在这个Release分支上测试，修改Bug等。同时，其它开发人员可以基于这条release分支开发新的Feature，但是这个新的Feature分支只能合并入下一个版本记住：一旦打了Release分支之后不要从Develop分支上合并新的改动到Release分支。发布Release分支时，合并Release到Master和Develop，同时在Master分支上打个Tag记住Release版本号，然后可以删除Release分支了。

Release
用于维护的分支：hotfix

分支命名

hotfix/bugCode（缺陷号）

发布后的维护工作或者紧急问题的快速修复也需要使用一个独立的分支。这是唯一一种可以直接基于master创建的分支。一旦问题被修复了，所做的改动应该被合并入master和develop分支（或者用于当前发布的分支）。在这之后，master上还要使用更新的版本号打好版本（标签/tag）号。

hotfix

二、实际应用

1、角色说明及对应虚拟人物

管理员（Master）[拥有建立和管理GIT项目，合并分支和代码，master打tag版本权限]
开发者（Developer）[拥有浏览，push非主分支，提交mr（merge request）工单权限]
浏览者（Guest）[如：测试人员，只能浏览，无push，mr等所有写权限]

2、实际操作

管理员初始化Master

master
管理员创建develop分支

简单的做法：让一个管理员在本地建立一个空的develop分支（如，2019第一个迭代，就可以命名为develop/2019-001），然后把它推送到服务器。develop分支将包含项目在某个开发阶段的所有历史，而master会是一个缩减版本。
```
git branch develop/2019-001
git push -u origin develop/2019-001
```
从maser上拉develop分支

管理员创建开发分支Feature，开发人员拉取对应的开发分支进行开发

管理员创建开发分支Feature

现在有两个开发任务，（如，一个叫用户管理（user），一个叫角色管理（role）），管理员在创建这两条开发分支时，父分支不能选择master，而要选择develop。

# 从develop/2019-001上拉用户管理（user）开发分支
git checkout -b reature/user develop/2019-001
git push -u origin reature/user
# 从develop/2019-001上拉角色管理（role）开发分支
git checkout -b reature/role develop/2019-001
git push -u origin reature/role

开发人员拉取对应的开发分支进行开发

# 开发人员A拉取远端用户管理（user）开发分支到本地进行开发
git checkout -b reature/user origin/reature/user
# 开发人员B拉取远端角色管理（role）开发分支到本地进行开发
git checkout -b reature/role origin/reature/role

从develop分支上拉开发分支Feature

开发人员开发及开发完成
- 开发人员开发
  
  Git三部曲：add/commit/push
```
git add <fileName>
git commit -m "commit message"
git push
```
- 开发完成
  
  用户管理功能做完了。开发团可以提出一个将所完成的功能合并入develop分支的请求。或者，团队中有一人可以自行将他的代码合并入本地的develop分支，然后再推送到中央仓库，然后删除功能分支
  
  新开发的功能代码永远不能直接合并入master
```
# 将远端develop拉到本地，方便解决冲突
git pull origin develop/2019-001
# 切换到develop分支
git checkout develop/2019-001
# 合并reature功能分支
git merge reature/user
# 推送远端
git push
# 删除reature功能分支
git branch -d reature/user
```
  Feature分支开发完后，往develop分支合
完成整合发布版本，开始测试

完成开发后要发版，（如，版本号定为V1.1），从开发分支develop/2019-001上拉版本分支release/V1.1.0
```
# 从开发分支develop/2019-001上拉版本分支release/V1.1.0
git checkout -b release/V1.1.0 develop/2019-001
```
这个分支专门用于发布前的准备，包括一些清理工作、全面的测试、文档的更新以及任何其他的准备工作。它与用于功能开发的分支相似，不同之处在于它是专为产品发布服务的。

一旦创建了这个分支并把它推向中央仓库，这次产品发布包含的功能也就固定下来了。任何还处于开发状态的功能只能等待下一个发布周期。

从develop分支拉发版分支，并开始测试修改bug等
完成版本发布

版本测试完成后，就要把发布分支合并入master和develop分支，然后再将发布分支删除。

发布分支扮演的角色是功能开发（develop）与官方发布（master）之间的一个缓冲。

注意，往develop分支的合并是很重要的，因为开发人员可能在发布分支上修复了一些关键的问题，而这些修复对于正在开发中的新功能是有益的。

并且，如果团队强调代码评审（Code Review），此时非常适合提出这样的请求。
```
# 将远端master拉到本地，方便解决冲突
git checkout master
# 合并版本分支
git merge release/V1.1.0
# 将合并结果推送远端
git push
# 将远端develop拉到本地，方便解决冲突
git checkout develop/2019-001
# 合并版本分支
git merge release/V1.1.0
# 将合并结果推送远端
git push
# 删除版本分支
git branch -d release/V1.1.0
```
无论什么时候我们把一些东西合并入master，我们都应该随即打上合适的标签。
```
# 在master上打上V1.1.0的标签
git tag -a V1.1.0 -m "权限管理" master
# 推送tags到远端
git push --tags
```

将release分支分别合入master和develop分支

遇到紧急BUG

随着上线的完成，突然发现一个紧急bug需要修复，这个时候测试人员分配一个bug号（如，20191221-001）并做记录以便后续测试，管理员拿到bug号基于master创建了一个用于维护的分支（如，issue/20191221-001）。开发人员在这个分支上修复了那个bug，然后把改动的代码直接合并入master，并打上版本，V1.1.1。
```
# 从master上拉维护分支
git checkout -b issue/20191221-001 master
# 修改并完成测试后合入master
# 切换到master
git checkout master
# 合并维护分支
git merge issue/20191221-001
# 将合并结果推送到远端
git push
```
从master拉issue分支修改bug，最后合入master
跟发布分支一样，在维护分支上的改动也需要合并入develop分支，用于记录该过程。随后，就可以将维护分支删除。

   # 切换到开发分支
   git checkout develop
   # 合并维护分支
   git merge issue/20191221-001
   # 讲合并结果推送到远端
   git push
   # 删除维护分支
   git branch -d issue/20191221-001

参考：workflow-gitflow How it works

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！

Git | IDEA中Git插件的用法

Mon, 25 Feb 2019 00:00:00 +0000

IDEA中Git插件的用法

一、IntelliJ IDEA中配置Git

1、安装Git

本地安装好git，并配置合理的SSH key 具体看这里

2、配置Git

IntelliJ IDEA->setting->Version Control->Git 将自己安装git的可执行文件路径填入Path to Git executable，点击 Test测试一下

二、新建项目

登录github上，然后在右上角找到 “create a new repo” 创建一个新的仓库。如下：

在Repository name填入test2，其他保持默认设置，点击“Create repository”按钮，就成功地创建了一个新的Git仓库：

复制git仓库的地址：https://github.com/CoderOfSong/test3.git。

三、上传项目到Git仓库

在你的idea里新建git仓库，这是新建本地仓库，等下会同步到线上git仓库

建好后文件名变为橙色，如图：

说明git仓库建好了，但是没有加入到暂存区，这时在需要提交的文件（或文件夹）上右击 -> Git -> Add

添加后，相应的文件名会变成绿色

然后提交项目，这里是先提交带本地仓库,在在需要提交的文件（或文件夹）上右击 -> Git -> Commit Directory ，然后点击 commit and push 推送到线上仓库。注意这里和svn不一样。

四、检出项目

选择checkout

输入远程仓库地址，然后clone即可

五、更新项目

按照图片中的步骤，顺序不能乱，先stash，然后pull，最后unstash 注意 stash 会让你输入标记名称，unstash 的时候选择想要的标记

如果代码有冲突，我们需要编辑冲突，我们一般选择merge，就是合并的意思，当然你也可以不合并直接使用线上的或者暂存里的代码。

六、切换分支

先更新远程分支, 点击Git -> pull,在弹出的窗口中选择要拉取的分支,如果在分支列表中没有新建的分支,可以点击刷新拉取远程库上的新分支.

右下角有个当前分支名称，点击会谈出一分支信息。如果你想切换分支，选中分支，点击右键checkout即可。

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！

Git | Git的安装

Thu, 21 Feb 2019 00:00:00 +0000

Git | Git的安装

1.Git的下载

下载地址：https://git-scm.com/download/win ，在页面选择对应的版本下载

2.Git的安装

1、双击安装文件，打开安装窗口，进入Information界面

2、点击“next”按钮，进入Select Destination Location界面，可根据自己的需求修改安装路径

3、点击“next”按钮，进入Select Componets界面，选择要安装的组件，详情见图

4、点击“next”，进入Select Start Menu Folder界面，设置开始菜单中快捷方式的目录名称

5、点击“Next”选择默认编辑器我选择的“Vim”

6、点击“next”，进入Adjusting your PATH environment界面，设置环境变量：选择使用什么样的命令行工具使用git，我选择了git bash和windows命令行。

7、点击“Next”选择传输后台使用OpenSSL

8、点击“next”按钮进入Configuring the line ending conversions界面，选择换行格式，windows上跨平台支持，unix以及非跨平台支持

9、点击“next”按钮进入配置终端模拟器（Configuring the terminal emulator to use with Git Bash）界面，默认设置

10、点击“next”按钮进入额外的配置选项（Configuring extra options），默认设置。允许系统缓存，允许信任证书管理

11、点击“Install”开始安装。

12、安装完成

13、检验是否安装成功回到电脑桌面，鼠标右击如果看到有两个git菜单则安装成功

3.Git的配置

安装完成后，还需要最后一步设置，在命令行输入如下：

git config --global user.name "git用户名"
git config --global user.email "git邮箱"

如图:

因为Git是分布式版本控制系统，所以需要填写用户名和邮箱作为一个标识。

注意：git config –global 参数，有了这个参数，表示你这台机器上所有的Git仓库都会使用这个配置，当然你也可以对某个仓库指定的不同的用户名和邮箱。

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！

Git | GIT和SVN的介绍

Mon, 18 Feb 2019 00:00:00 +0000

Git | GIT和SVN的介绍

一、什么是GIT和SVN

1.SVN(集中式版本控制系统)

SVN是Subversion的简称，是一个开放源代码的版本控制系统,支持大多数常见的操作系统。作为一个开源的版本控制系统,Subversion管理着随时间改变的数据。这些数据放置在一个中央资料档案库(repository)中。这个档案库很像一个普通的文件服务器,不过它会记住每一次文件的变动。这样你就可以把档案恢复到旧的版本,或是浏览文件的变动历史。Subversion是一个通用的系统,可用来管理任何类型的文件,其中包括了程序源码。

工作流程

集中式管理的工作流程如下图：

集中式代码管理的核心是服务器，所有开发者在开始新一天的工作之前必须从服务器获取代码，然后开发，最后解决冲突，提交。所有的版本信息都放在服务器上。如果脱离了服务器，开发者基本上可以说是无法工作的。下面举例说明：

开始新一天的工作：
1、从服务器下载项目组最新代码。
2、进入自己的分支，进行工作，每隔一个小时向服务器自己的分支提交一次代码（很多人都有这个习惯。因为有时候自己对代码改来改去，最后又想还原到前一个小时的版本，或者看看前一个小时自己修改了哪些代码，就需要这样做了）。
3、下班时间快到了，把自己的分支合并到服务器主分支上，一天的工作完成，并反映给服务器。

2.GIT(分布式版本控制系统)

GIT是一款免费、开源的分布式版本控制系统，用于敏捷高效地处理任何或小或大的项目 GIT是一个开源的分布式版本控制系统，用以有效、高速的处理从很小到非常大的项目版本管理。GIT是 Linus Torvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本控制软件。分布式相比于集中式的最大区别在于开发者可以提交到本地，每个开发者通过克隆（git clone），在本地机器上拷贝一个完整的GIT仓库.

工作流程

GIT开发过程如下图：

GIT的功能特性：

从一般开发者的角度来看，GIT有以下功能：

从服务器上克隆完整的GIT仓库（包括代码和版本信息）到单机上。
在自己的机器上根据不同的开发目的，创建分支，修改代码。
在单机上自己创建的分支上提交代码。
在单机上合并分支。
把服务器上最新版的代码fetch下来，然后跟自己的主分支合并。
生成补丁（patch），把补丁发送给主开发者。
看主开发者的反馈，如果主开发者发现两个一般开发者之间有冲突（他们之间可以合作解决的冲突），就会要求他们先解决冲突，然后再由其中一个人提交。如果主开发者可以自己解决，或者没有冲突，就通过。
一般开发者之间解决冲突的方法，开发者之间可以使用pull 命令解决冲突，解决完冲突之后再向主开发者提交补丁。

从主开发者的角度（假设主开发者不用开发代码）看，GIT有以下功能：

查看邮件或者通过其它方式查看一般开发者的提交状态。
打上补丁，解决冲突（可以自己解决，也可以要求开发者之间解决以后再重新提交，如果是开源项目，还要决定哪些补丁有用，哪些不用）。
向公共服务器提交结果，然后通知所有开发人员。

二、GIT和SVN的区别

SVN属于集中化的版本控制系统，有个不太精确的比喻:SVN = 版本控制+ 备份服务器

SVN使用起来有点像是档案仓库的感觉，支持并行读写文件，支持代码的版本化管理，功能包括取出、导入、更新、分支、改名、还原、合并等。
Git是一个分布式版本控制系统，操作命令包括：clone，pull，push,branch ,merge ,push,rebase，Git擅长的是程序代码的版本化管理。
GIT跟SVN一样有自己的集中式版本库或服务器。但，GIT更倾向于被使用于分布式模式，也就是每个开发人员从中心版本库/服务器上chect out代码后会在自己的机器上克隆一个自己的版本库。可以这样说，如果你被困在一个不能连接网络的地方时，就像在飞机上，地下室，电梯里等，你仍然能够提交文件，查看历史版本记录，创建项目分支，等。对一些人来说，这好像没多大用处，但当你突然遇到没有网络的环境时，这个将解决你的大麻烦。
GIT把内容按元数据方式存储，而SVN是按文件

所有的资源控制系统都是把文件的元信息隐藏在一个类似.svn,.cvs等的文件夹里。如果你把.git目录的体积大小跟.svn比较，你会发现它们差距很大。因为,.git目录是处于你的机器上的一个克隆版的版本库，它拥有中心版本库上所有的东西，例如标签，分支，版本记录等。
分支在SVN中一点不特别，就是版本库中的另外的一个目录。如果你想知道是否合并了一个分支，你需要手工运行像这样的命令svn propget svn:mergeinfo，来确认代码是否被合并。然而，处理GIT的分支却是相当的简单和有趣。你可以从同一个工作目录下快速的在几个分支间切换。你很容易发现未被合并的分支，你能简单而快捷的合并这些文件。
GIT没有一个全局的版本号，而SVN有

目前为止这是跟SVN相比GIT缺少的最大的一个特征。你也知道，SVN的版本号实际是任何一个相应时间的源代码快照。我认为它是从CVS进化到SVN的最大的一个突破。因为GIT和SVN从概念上就不同，我不知道GIT里是什么特征与之对应。如果你有任何的线索，请在评论里奉献出来与大家共享。
GIT的内容完整性要优于SVN：

GIT的内容存储使用的是SHA-1哈希算法。这能确保代码内容的完整性，确保在遇到磁盘故障和网络问题时降低对版本库的破坏。

三、GIT和SVN的优缺点

1.SVN 的优缺点

SVN对中文支持好，操作简单，使用没有难度，美工人员，产品人员，测试人员，实施人员都可轻松上手。使用界面统一，功能完善，操作方便。

2.Git的优缺点

对程序源代码进行差异化的版本管理，代码库占极少的空间。易于代码的分支化管理。不支持中文，图形界面支持差，使用难度大。不易推广。

3.适用范围

适用对象不同。Git适用于参与开源项目的开发者。他们由于水平高，更在乎的是效率而不是易用性。SVN则不同，它适合普通的公司开发团队。使用起来更加容易。
使用的场合不同。Git适用于通过Internet，有多个开发角色的单个项目开发，SVN适合企业内部由项目经理统一协调的多个并行项目的开发。
权限管理策略不同。Git没有严格的权限管理控制，只要有帐号，就可以导出、导入代码，甚至执行回退操作。SVN则有严格的权限管理，可以按组、按个人进行针对某个子目录的权限控制。区分读、写权限。更严格的，不支持回退操作。保证代码永远可以追踪。
分支(branch)的使用范围不一样。Git中，你只能针对整个仓库作branch,而且一旦删除，便无法恢复。而SVN中，branch可以针对任何子目录，它本质上是一个拷贝操作。所以，可以建立非常多、层次性的branch,并且，在不需要时将其删除，而以后需要时只要checkout老的SVN版本就可以了。
基于第三点，Git适用于单纯的软件项目，典型的就是一些开源项目，比如Linux内核、busybox等。相反，SVN擅长多项目管理。比如，你可以在一个SVN仓库中存放一个手机项目的bsp/设计文档/文件系统/应用程序/自动化编译脚本，或者在一个SVN中存放5款手机项目的文件系统。git中必须建立n(项目数)*m（组件数）个仓库。SVN中只需要最多n或者m个就可以了。
Git使用128位ID作为版本号，而且checkout时要注明是哪个branch,而SVN使用一个递增的序列号作为全局唯一的版本号，更加简明易懂。虽然可以使用gittag来建立一些文字化的别名，但是毕竟那只是针对特殊版本。
可跟踪性，git的典型开发过程为：建立分支，进行开发，提交到本地master，删除分支。这样做的后果是以前的修改细节会丢失。而在SVN下做同样的事情，不会丢失任何细节。这里是一个有趣的链接，表明了git下典型的工作方式：（以master为核心，不断创建新branch,删除旧branch):
局部更新，局部还原。SVN由于是在每个文件夹建立一个.svn文件夹来实现管理，所以可以很简单实现局部更新或者还原。假如你只希望更新某些部分，则svn可以很好实现。同时代码写错了，同时可以很好实现局部还原，当然git也可以通过历史版本还原，但是无法简单地实现局部还原。

4.SVN属于集中化的版本控制系统

这种做法带来了许多好处，特别是相较于老式的本地VCS来说。现在，每个人都可以一定程度上看到项目中的其他人正在做些什么。而管理员也可以轻松掌控每个开发者的权限。

事分两面，有好有坏。这么做最显而易见的缺点是中央服务器的单点故障。若是宕机一小时，那么在这一小时内，谁都无法提交更新、还原、对比等，也就无法协同工作。如果中央服务器的磁盘发生故障，并且没做过备份或者备份得不够及时的话，还会有丢失数据的风险。最坏的情况是彻底丢失整个项目的所有历史更改记录，被客户端提取出来的某些快照数据除外，但这样的话依然是个问题，你不能保证所有的数据都已经有人提取出来。 Subversion原理上只关心文件内容的具体差异。每次记录有哪些文件作了更新，以及都更新了哪些行的什么内容。

Subversion的特点概括起来主要由以下几条

每个版本库有唯一的URL（官方地址），每个用户都从这个地址获取代码和数据；
获取代码的更新，也只能连接到这个唯一的版本库，同步以取得最新数据；
提交必须有网络连接（非本地版本库）；
提交需要授权，如果没有写权限，提交会失败；
提交并非每次都能够成功。如果有其他人先于你提交，会提示“改动基于过时的版本，先更新再提交”… 诸如此类；
冲突解决是一个提交速度的竞赛：手快者，先提交，平安无事；手慢者，后提交，可能遇到麻烦的冲突解决。

6.Git属于分布式的版本控制系统

自2005年诞生于以来，Git日臻成熟完善，在高度易用的同时，仍然保留着初期设定的目标。它的速度飞快，极其适合管理大项目，它还有着令人难以置信的非线性分支管理系统，可以应付各种复杂的项目开发需求。

与SVN不同，Git记录版本历史只关心文件数据的整体是否发生变化。Git并不保存文件内容前后变化的差异数据。实际上，Git更像是把变化的文件作快照后，记录在一个微型的文件系统中。每次提交更新时，它会纵览一遍所有文件的指纹信息并对文件作一快照，然后保存一个指向这次快照的索引。为提高性能，若文件没有变化，Git不会再次保存，而只对上次保存的快照作一连接。

简略的说，Git具有以下特点：

Git中每个克隆(clone)的版本库都是平等的。你可以从任何一个版本库的克隆来创建属于你自己的版本库，同时你的版本库也可以作为源提供给他人，只要你愿意。
Git的每一次提取操作，实际上都是一次对代码仓库的完整备份。提交完全在本地完成，无须别人给你授权，你的版本库你作主，并且提交总是会成功。
甚至基于旧版本的改动也可以成功提交，提交会基于旧的版本创建一个新的分支。
Git的提交不会被打断，直到你的工作完全满意了，PUSH给他人或者他人PULL你的版本库，合并会发生在PULL和PUSH过程中，不能自动解决的冲突会提示您手工完成。
冲突解决不再像是SVN一样的提交竞赛，而是在需要的时候才进行合并和冲突解决。

总之，公司的开发团队在进行的项目开发管理时，svn是更好的选择，团队成员共同维护公司的中心版本。若是开源项目，则git更加适合，每个人都可以维护自己专属的版本，同时有github开源社区支持。

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！

设计模式 | 享元模式

Tue, 13 Nov 2018 00:00:00 +0000

知识点十三：享元模式

一、概述

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。它属于23种GOF设计模式的结构型设计模式 ，它提供了减少对象数量从而改善应用所需的对象结构的方式。

在享元模式中通常会出现工厂模式，需要创建一个享元工厂来负责维护一个享元池(Flyweight Pool)（用于存储具有相同内部状态的享元对象），将对象放在享元池中重用现有的同类对象，如果未找到匹配的对象，则创建新对象。

二、优缺点及使用场景

1、优点

它可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份。
享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享。

2、缺点

享元模式使得系统更加复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。
为了使对象可以共享，享元模式需要将享元对象的状态外部化，而读取外部状态使得运行时间变长。

3、使用场景

一个系统有大量相同或者相似的对象，由于这类对象的大量使用，造成内存的大量耗费。
对象的大部分状态都可以外部化，可以将这些外部状态传入对象中(细粒度对象)。
使用享元模式需要维护一个存储享元对象的享元池，而这需要耗费资源，因此，应当在多次重复使用享元对象时才值得使用享元模式。

三、模式中的角色及职责和实现方式

1、角色

抽象享元（Flyweight）角色：所有具体享元类的父类，规定一些需要实现的公共接口。
具体享元（ConcreteFlyweight）角色：具体的享元实现对象，必须是可共享的，需要封装享元对象的内部状态。
享元工厂（FlyweightFactory）角色：享元工厂，主要用来创建并管理共享的享元对象，并对外提供访问共享享元的接口。

2、实现方式

享元模式的核心在于享元工厂类，享元工厂类的作用在于提供一个用于存储享元对象的享元池，用户需要对象时，首先从享元池中获取，如果享元池中不存在，则创建一个新的享元对象返回给用户，并在享元池中保存该新增对象。

四、Java中的实现方式

Person.java

/**
 * @Description: 抽象享元（Flyweight）角色 人
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/22 14:58
 */
public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

Staff.java

/**
 * @Description: 具体享元（ConcreteFlyweight）角色 员工
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/22 15:01
 */
public class Staff extends Person {
    private String number; //员工号

    public Staff() {
        super();
    }

    public Staff(String name, int age) {
        super(name, age);
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }
}

StaffFactory.java

/**
 * @Description: 享元工厂（FlyweightFactory）角色
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/22 15:05
 */
public class StaffFactory {
    //我们希望通过员工号来找到员工
    private Map<String,Staff> pool;//资源池

    public StaffFactory() {
        pool = new HashMap<String, Staff>();
    }

    public Staff getStaff(String number){
        Staff staff = pool.get(number);
        //如果staff为null则new一个空的
        if(staff == null){
            System.out.println("没有该员工,添加该员工");
            staff = new Staff();
            staff.setNumber(number);
            pool.put(number,staff);
        }
        return staff;
    }
}

MainClass.java

/**
 * @Description: 有抽象享元角色的实现,客户端调用
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/22 14:58
 */
public class MainClass {
    public static void main(String[] args) {
        //1.创建工厂
        StaffFactory factory = new StaffFactory();
        //2.从工厂取值
        Staff staff1 = factory.getStaff("001");
        Staff staff2 = factory.getStaff("002");
        Staff staff3 = factory.getStaff("003");

        System.out.println(staff1.getNumber());
        System.out.println(staff2.getNumber());
        System.out.println(staff3.getNumber());

        System.out.println("==============");
        //这时候资源池中就有员工123了,现在把"002"改为"001"看是不是同一个对象
        staff2 = factory.getStaff("001");
        if(staff1 == staff2){
            System.out.println("是同一个对象");
        }else{
            System.out.println("不是同一个对象");
        }
    }
}

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！

设计模式 | 组合模式

Mon, 12 Nov 2018 00:00:00 +0000

知识点十二：组合模式

一、概述

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。它属于23种GOF设计模式的结构型设计模式 ，它创建了对象组的树形结构。

这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。

二、优缺点及使用场景

1、优点

组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
在组合模式中增加新的容器构件和叶子构件都很方便，无须对现有类库进行任何修改，符合“开闭原则”。
组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和容器对象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。

2、缺点

在增加新构件时很难对容器中的构件类型进行限制。有时候我们希望一个容器中只能有某些特定类型的对象，例如在某个文件夹中只能包含文本文件，使用组合模式时，不能依赖类型系统来施加这些约束，因为它们都来自于相同的抽象层，在这种情况下，必须通过在运行时进行类型检查来实现，这个实现过程较为复杂。

3、使用场景

在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，客户端可以一致地对待它们。
在一个使用面向对象语言开发的系统中需要处理一个树形结构。
在一个系统中能够分离出叶子对象和容器对象，而且它们的类型不固定，需要增加一些新的类型。

三、模式中的角色及其职责和实现方式

1、角色

抽象构件（Component）角色：它可以是接口或抽象类，为叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。
叶子构件（Leaf）角色：它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。
容器构件（Composite）角色：它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

2、实现方式

组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象构件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶子，也可以包含容器，以此实现递归组合，形成一个树形结构。

四、Java中的实现

IFile.java

/**
 * @Description: 文件节点抽象(是文件和目录的父类)
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/20 9:15
 */
public interface IFile {
    //显示文件名称
    public void display();

    //添加节点
    public boolean add(IFile file);
    //删除节点
    public boolean remove(IFile file);
    //获取节点
    public List<IFile> getChild();
}

File.java

/**
 * @Description: 
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/20 9:20
 */
public class File implements IFile {
    private String name;

    public File(String name) {
        this.name = name;
    }


    public void display() {
        System.out.println(name);
    }

    public boolean add(IFile file) {
        return false;
    }

    public boolean remove(IFile file) {
        return false;
    }

    public List<IFile> getChild() {
        return null;
    }
}

Folder.java

/**
 * @Description: 
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/20 9:23
 */
public class Folder implements IFile {
    private String name;
    private List<IFile> children;

    public Folder(String name) {
        this.name = name;
        children = new ArrayList<IFile>();
    }

    public void display() {
        System.out.println(name);
    }

    public boolean add(IFile file) {
        return children.add(file);
    }

    public boolean remove(IFile file) {
        return children.remove(file);
    }

    public List<IFile> getChild() {
        return children;
    }
}

MainClass.java

/**
 * @Description: 客户端
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/20 9:29
 */
public class MainClass {
    public static void main(String[] args) {
        //构造c盘
        Folder rootFolder = new Folder("C:");
        //ling文件夹
        Folder lingFolder = new Folder("ling");
        //ling.txt文件
        File lingFile = new File("ling.txt");

        rootFolder.add(lingFolder);
        rootFolder.add(lingFile);
        //遍历第一次
        displayTree(rootFolder,0);

        System.out.println("================");

        //这时候添加ling文件的兄弟节点
        Folder songFolder = new Folder("song");
        //ling.txt文件
        File songFile = new File("song.txt");
        rootFolder.add(songFolder);
        rootFolder.add(songFile);
        //遍历第二次
        displayTree(rootFolder,0);

        System.out.println("================");

        //这时候添加song文件的子节点
        Folder deFolder = new Folder("de");
        //ling.txt文件
        File deFile = new File("de.txt");
        songFolder.add(deFolder);
        songFolder.add(deFile);
        //遍历第三次
        displayTree(rootFolder,0);
    }

    //遍历树节点,打印名称
    public static void displayTree(IFile rootFolder, int deep) {
        //层次分隔符,为了好看,无实意
        for (int i = 0; i < deep; i++) {
            System.out.print("--");
        }

        rootFolder.display();
        //获取子节点
        List<IFile> children = rootFolder.getChild();
        //遍历
        for (IFile child : children) {
            //如果是文件就答应文件的文件名
            if (child instanceof File) {
                for (int i = 0; i <= deep; i++) {
                    System.out.print("--");
                }
                child.display();
            } else {
                displayTree(child,deep+1);
            }
        }
    }
}

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！

设计模式 | 桥接模式

Sun, 11 Nov 2018 00:00:00 +0000

知识点十一：桥接模式

一、概述

桥接模式又叫做Bridge模式，属于23种GOF设计模式的结构型设计模式 。桥接模式基于类的最小设计原则，通过使用封装，聚合以及继承等行为来让不同的类承担不同的责任。它的主要特点是把抽象（abstraction)与行为实现（implementation)分离开来，从而可以保持各部分的独立性以及应对它们的功能扩展。

桥接模式将继承关系转化成关联关系，它降低了类与类之间的耦合度，减少了系统中类的数量，也减少了代码量。

二、优缺点及使用场景

1、优点

分离抽象接口及其实现部分。提高了比继承更好的解决方案。
桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。
实现细节对客户透明，可以对用户隐藏实现细节。

2、缺点

桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。
桥接模式要求正确识别出系统中两个独立变化的维度，因此其使用范围具有一定的局限性。

3、模式使用场景

如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。
对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用。
一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。

三、场景中的角色及功能和实现方式

1、角色

Abstraction 抽象类接口（接口或抽象类）：维护对行为实现（Implementor)的引用。它的角色就是桥接类。
Refined Abstraction：Abstraction子类
Implementor 行为实现类接口：Abstraction接口定义了基于Implementor接口的更高层次的操作
Concretelmplementor：Implementor子类

2、实现方式

四、在Java中的实现

解决问题：在汽车生产中不同用途的车会搭配不同的发动机。

普通解决方法（直接上图了，不写代码了。。）：

使用桥接模式：

Engine.java

/**
 * @Description: 行为实现接口,安装发动机
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/16 16:19
 */
public interface Engine {
    public void installEngine();
}

Engine2000.java

/**
 * @Description: 行为实现,安装2000CC的发动机
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/16 16:20
 */
public class Engine2000 implements Engine {
    public void installEngine() {
        System.out.println("安装2000CC的发动机");
    }
}

Engine2200.java

/**
 * @Description: 行为实现,安装2200CC的发动机
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/16 16:35
 */
public class Engine2200 implements Engine {
    public void installEngine() {
        System.out.println("安装2200的发动机");
    }
}

Car.java

/**
 * @Description: car,桥接类
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/16 15:42
 */
public abstract class Car {
    //桥接模式的关键,接口的引用,扩展很方便
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public abstract void installEngine();
}

Bus.java

/**
 * @Description: 具体实现
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/16 16:09
 */
public class Bus extends Car {

    public Bus(Engine engine) {
        super(engine);
    }

    public void installEngine() {
        System.out.print("Bus:");
        this.getEngine().installEngine();
    }
}

Taxi.java

/**
 * @Description: 具体实现
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/16 17:14
 */
public class Taxi extends Car {
    public Taxi(Engine engine) {
        super(engine);
    }

    public void installEngine() {
        System.out.print("Taxi:");
        this.getEngine().installEngine();
    }
}

MainClass.java

/**
 * @Description: 客户端调用
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/16 15:32
 */
public class MainClass {
    public static void main(String[] args) {
        //先做2种型号的发动机
        Engine engine2000 = new Engine2000();
        Engine engine2200 = new Engine2200();

        //将发动机嵌入到相应的车中
        Car bus = new Bus(engine2200);
        bus.installEngine();

        Car taxi = new Taxi(engine2000);
        taxi.installEngine();
    }
}

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！

设计模式 | 外观模式

Sat, 10 Nov 2018 00:00:00 +0000

知识点十：外观模式

一、概述

外观模式（Facade Pattern）又称门面模式，属于23种GOF设计模式的结构型设计模式 。 Facade模式为一组具有类似功能的类群，比如类库，子系统等等，提供一个一致的简单的界面。这个一致的简单的界面被称作facade。它向现有的系统添加一个接口，来隐藏系统的复杂性。

这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

封装交互，简化调用。

二、优缺点及使用场景

1、优点

松散耦合：外观模式松散了客户端与子系统的耦合关系，让子系统内部的模块能更容易扩展和维护。
简单易用：外观模式让子系统更加易用，客户端不再需要了解子系统内部的实现，也不需要跟众多子系统内部的模块进行交互，只需要跟外观类交互就可以了。
更好的划分访问层次：通过合理使用Facade，可以帮助我们更好地划分访问的层次。有些方法是对系统外的，有些方法是系统内部使用的。把需要暴露给外部的功能集中到外观中，这样既方便客户端使用，也很好地隐藏了内部的细节。

2、缺点

不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。

3、使用场景

为复杂的模块或子系统提供外界访问的模块。
子系统相对独立。
预防低水平人员带来的风险。

三、模式中的角色及作用和实现方式

1、角色

功能提供者（Packages ）角色：指提供功能的类群（模块或子系统）。可以同时有一个或者多个子系统。每个子系统都不是一个单独的类，而是一个类的集合（如下面的子系统就是由ModuleA、ModuleB、ModuleC三个类组合而成）。每个子系统都可以被客户端直接调用，或者被门面角色调用。子系统并不知道门面的存在，对于子系统而言，门面仅仅是另外一个客户端而已。
门面（Facade）角色：为调用方定义简单的调用接口。客户端可以调用这个角色的方法。此角色知晓相关的（一个或者多个）子系统的功能和责任。在正常情况下，本角色会将所有从客户端发来的请求委派到相应的子系统去。
调用者（Clients）角色：通过Facade接口调用提供某功能的内部类群。

2、实现方式

四、在Java中的实现方式

ModuleA.java

/**
 * @Description: 子系统提供的功能A
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/15 16:28
 */
public class ModuleA {
    public void testA(){
        System.out.println("A模块,方法A");
    }
}

ModuleB.java

/**
 * @Description: 子系统提供的功能B
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/15 16:28
 */
public class ModuleB {
    public void testB(){
        System.out.println("B模块,方法B");
    }
}

ModuleC.java

/**
 * @Description: 子系统提供的功能C
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/15 16:28
 */
public class ModuleC {
    public void testC(){
        System.out.println("C模块,方法C");
    }
}

Facade.java

/**
 * @Description: 外观类
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/15 16:50
 */
public class Facade {
    private ModuleA moduleA;
    private ModuleB moduleB;
    private ModuleC moduleC;

    public Facade() {
        moduleA = new ModuleA();
        moduleB = new ModuleB();
        moduleC = new ModuleC();
    }

    public void test(){
        this.moduleA.testA();
        this.moduleB.testB();
        this.moduleC.testC();
    }
}

MainClass.java

/**
 * @Description: 调用者
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/15 15:45
 */
public class MainClass {
    public static void main(String[] args) {
        Facade facade = new Facade();
        //通过门面封装的方法,调用其子系统的方法
        facade.test();
    }
}

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！

设计模式 | 代理模式

Fri, 09 Nov 2018 00:00:00 +0000

知识点九：代理模式

一、概述

1、什么是代理模式

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。它属于23种GOF设计模式的结构型设计模式 。在代理模式中，我们创建具有（包含）现有对象的对象，以便向外界提供功能接口。

打个比方代理模式就是相当于我们租房子，我们本身没有找房源的这个功能，但是中介（代理类）有，我们就把我们本身具有的功能（挑房子）给中介，这时候中介就有了新功能（挑房子+找房源），这时候让中介去找房子

2、模式中包含角色及实现

角色
- 抽象主题（Subject）角色：真实主题与代理主题的共同接口。
- 真实主题（RealSubject）角色：定义了代理角色所代表的真实对象。
- 代理主题（Proxy）角色：含有对真实主题角色的引用，代理角色通常在将客户端调用传递给真是主题对象之前或者之后执行某些操作，而不是单纯返回真实的对象。
实现

3、为什么要用代理模式

中介隔离作用：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
开闭原则，增加功能：代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

4、代理模式的分类

我们有多种不同的方式来实现代理。如果按照代理创建的时期来进行分类的话，可以分为两种：静态代理和动态代理。静态代理是由程序员创建或特定工具自动生成源代码，在对其编译。在程序运行之前，代理类.class文件就已经被创建了。动态代理是在程序运行时通过反射机制动态创建的。

二、静态代理

1、优缺点

优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。

缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。

2、实现

1、Subject.java

/**
 * @Description: 抽象主题,服务类接口
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/14 17:45
 */
public interface Subject {
    public void tiaoFangZi();
}

2、RealSubject.java

/**
 * @Description: 真实主题,就是我们租房子的
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/14 17:45
 */
public class RealSubject implements Subject {
    public void tiaoFangZi() {
        System.out.println("我会挑房子");
    }
}

3、ProxySubject.java

/**
 * @Description: 代理主题,代理类 中介
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/14 17:46
 */
public class ProxySubject implements Subject {

    private Subject subject;
	//关键,将被代理对象传进来
    public ProxySubject(final Subject subject) {
        this.subject = subject;
    }

    public void tiaoFangZi() {
        System.out.println("找房源");
        subject.tiaoFangZi();
    }
}

4、MainClass.java

/**
 * @Description:
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/14 17:44
 */
public class MainClass {
    public static void main(String[] args) {
        Subject subject = new RealSubject();
        subject.tiaoFangZi();

        System.out.println("============");

        ProxySubject proxySubject = new ProxySubject(subject);
        proxySubject.tiaoFangZi();
    }
}

三、动态代理

在动态代理中我们不再需要再手动的创建代理类，我们只需要编写一个动态处理器就可以了。真正的代理对象由JDK再运行时为我们动态的来创建。

1、Proxy 实现动态代理（代理有接口的类）

DynamicProxyHandler.java

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @Description: 动态代理类, 实现invoke方法
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/14 18:21
 */
public class DynamicProxyHandler implements InvocationHandler {

    private Object object;

    public DynamicProxyHandler(final Object object) {
        this.object = object;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我会找房源");
        Object result = method.invoke(object, args);
        return result;
    }
}

MainClass.java

import java.lang.reflect.Proxy;

/**
 * @Description:
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/14 17:44
 */
public class MainClass {
    public static void main(String[] args) {
        Subject subject = new RealSubject();
        /**
         * ClassLoader loader:指定当前目标对象使用的类加载器,获取加载器的方法是固定的
         * Class<?>[] interfaces:指定目标对象实现的接口的类型,使用泛型方式确认类型
         * InvocationHandler:指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法
         */
        Subject proxySubject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),
                new Class[]{Subject.class},
                new DynamicProxyHandler(subject));
        proxySubject.tiaoFangZi();
    }
}

2、CGLib实现动态代理（代理没有接口的类）

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

pom.xml中加入依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

CglibProxy.java

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @Description:
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/14 18:36
 */
public class CglibProxy implements MethodInterceptor {
    private Object target;//业务类对象，供代理方法中进行真正的业务方法调用

    //相当于JDK动态代理中的绑定
    public Object getInstance(Object target) {
        this.target = target;  //给业务对象赋值
        Enhancer enhancer = new Enhancer(); //创建加强器，用来创建动态代理类
        enhancer.setSuperclass(this.target.getClass());  //为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
        //设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
        enhancer.setCallback(this);
        // 创建动态代理类对象并返回
        return enhancer.create();
    }
    // 实现回调方法
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("我会找房源");
        proxy.invokeSuper(obj, args); //调用业务类（父类中）的方法
        return null;
    }
}

MainClass.java

/**
 * @Description:
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/14 17:44
 */
public class MainClass {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        CglibProxy cglibProxy = new CglibProxy();
        RealSubject realSubjectProxy =
                (RealSubject) cglibProxy.getInstance(realSubject);
        realSubjectProxy.tiaoFangZi();
    }
}

CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！

设计模式 | 装饰者模式

Thu, 08 Nov 2018 00:00:00 +0000

知识点八：装饰者模式

一、概述

装饰器模式（Decorator Pattern）又叫包装模式，允许向一个现有的对象添加新的功能，同时又不改变其结构。它属于23种GOF设计模式的结构型设计模式 ，它是继承关系的一个替换方案。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

二、优缺点和使用场景

1、优点

装饰者模式可以提供比继承更多的灵活性。
可以通过一种动态的方式来扩展一个对象的功能，在运行时选择不同的装饰器，从而实现不同的行为。
通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合。可以使用多个具体装饰类来装饰同一对象，得到功能更为强大的对象。
具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，在使用时再对其进行组合，原有代码无须改变，符合“开闭原则”。

2、缺点

会产生很多的小对象，增加了系统的复杂性
这种比继承更加灵活机动的特性，也同时意味着装饰模式比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为烦琐。

3、使用场景

在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
需要动态地给一个对象增加功能，这些功能也可以动态地被撤销。当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。

三、模式中包含的角色和其职责以及模式实现方式

1、角色

抽象组件（Component）角色：定义一个抽象接口，来规范准备附加功能的类

具体组件（ConcreteComponent）角色：将要被附加功能的类，实现抽象构件角色接口

抽象装饰者（Decorator）角色：持有对具体构件角色的引用并定义与抽象构件角色一致的接口

具体装饰（ConcreteDecorator）角色：实现抽象装饰者角色，负责对具体构件添加额外功能。

2、模式实现方式

定义一个对象接口，可以给这些对象动态地添加职责（Component）。
定义一个对象，可以给这个对象添加一些职责（ConcreteComponent）。
维持一个指向Component实例的引用，并定义一个与Component接口一致的接口（Decorator）。
具体的装饰对象，给内部持有的具体被装饰对象，增加具体的职责（ConcreteDecorator）。

四、在Java中的实现

需求：目前有个会跑的车，需要为该车添加飞的功能；

抽象组件(Car.java)

/**
 * @Description: 抽象组件
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/12 20:32
 */
public interface Car {
    public void show();
}

具体组件(RunCar.java)

/**
 * @Description: 具体组件,定义组件初始功能,原程序
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/13 15:39
 */
public class RunCar implements Car {
    public void run() {
        System.out.println("这车可以跑");
    }

    public void show() {
        this.run();
    }
}

抽象汽车的装饰器(CarDecorator.java)

/**
 * @Description: 抽象汽车的装饰器
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/13 15:33
 */
public abstract class CarDecorator implements Car{
    private Car car;

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    public CarDecorator(Car car) {
        this.car = car;
    }

    public abstract void show();
}

具体装饰角色(FlyCarDecorator.java)

/**
 * @Description: 具体装饰角色,装饰飞的功能
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/13 15:24
 */
public class FlyCarDecorator extends CarDecorator {

    public FlyCarDecorator(Car car) {
        super(car);
    }

    public void show() {
        this.getCar().show();
        this.fly();
    }

    public void fly(){
        System.out.println("这车会飞");
    }
}

测试(MainClass.java)

/**
 * @Description:
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/12 20:32
 */
public class MainClass {
    public static void main(String[] args) {
        //先实例一辆车
        RunCar car = new RunCar();
        //把这车给飞行装饰器装饰,得到飞行功能
        FlyCarDecorator flyCar = new FlyCarDecorator(car);
        //看效果
        flyCar.show();
    }
}

这时候需要添加功能，车可以游，只需要添加响应的装饰类就好，如：

具体装饰角色(SwimCarDecorator.java)

/**
 * @Description: 具体装饰角色,装饰游的功能
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/13 16:00
 */
public class SwimCarDecorator extends CarDecorator implements Car {
    public SwimCarDecorator(Car car) {
        super(car);
    }

    public void show() {
        this.getCar().show();
        this.Swim();
    }

    //要添加的功能
    public void Swim(){
        System.out.println("这车可以游");
    }
}

测试(MainClass.java)

/**
 * @Description:
 * @Author: Ling.D.S
 * @Date: Created in 2018/11/12 20:32
 */
public class MainClass {
    public static void main(String[] args) {
        //先实例一辆车
        RunCar car = new RunCar();
        //把这车给飞行装饰器装饰,得到飞行功能
        FlyCarDecorator flyCar = new FlyCarDecorator(car);
        //看效果
        flyCar.show();

        System.out.println("========================");

        //添加功能
        SwimCarDecorator swimCar = new SwimCarDecorator(flyCar);
        swimCar.show();
    }
}

转载请注明原地址，宋德凌的博客：http://CoderOfSong.github.io 谢谢！