一 ，责任链模式
1,有序责任链模式
1,应用场景
任务处理 和审批流程
2，逻辑讲解
比如 在一个公司场景里面 工程师分等级级别 ，高级（马总），中级（朱工），初级（我），公司有一个需求 心电图绘制，由于 本人技术有限，无法写出来，只能告诉上级，我写不出来，我告诉朱工 朱工说 我是搞java的 不会Android ，然后朱工告诉马总 我也不会写，马总说 我出钱找人写，然后问题解决了
如果用代码怎么标识那
- 首先我先创建一个接口，里面有两个方法 一个是执行内容，一个是拥有的技能列表
interface HandleIntercept {
//任务
fun process(task: String)
//技术列表
fun technologyList(): List<String>
}
- 然后有三个去实现上面的一个接口 我，朱工，马总
class MineHandleIntercept : HandleIntercept {
override fun process(task: String) {
println("我自己解决了$task")
}
override fun technologyList(): List<String> {
val technologyList = mutableListOf<String>()
technologyList.add("吹吹牛")
technologyList.add("增删改查")
technologyList.add("Android")
technologyList.add("绘个界面")
return technologyList
}
}
class ZhuHandleIntercept : HandleIntercept {
override fun process(task: String) {
println("朱工自己解决了$task")
}
override fun technologyList(): List<String> {
val technologyList = mutableListOf<String>()
technologyList.add("管理")
technologyList.add("java")
technologyList.add("写文档")
return technologyList
}
}
class MaHandleIntercept : HandleIntercept {
override fun process(task: String) {
println("马总自己解决了$task")
}
override fun technologyList(): List<String> {
val technologyList = mutableListOf<String>()
technologyList.add("管理所有人")
technologyList.addAll(solutionTaskForMoney())//任何对象 能花钱解决的
return technologyList
}
/**
* 花钱能解决的
*/
private fun solutionTaskForMoney(): List<String> {
val mineHandleIntercept = MineHandleIntercept()
val zhuHandleIntercept = ZhuHandleIntercept()
val list = mutableListOf<String>()
list.addAll(mineHandleIntercept.technologyList())
list.addAll(zhuHandleIntercept.technologyList())
list.add("绘制心电图")
list.add("绘制心电向量")
return list
}
}
- 上面是三个雷已经创建完毕，首先我们有一个任务 是 绘制心电图 这个任务，我们用代码执行以下
@JvmStatic
fun main(args: Array<String>) {
val mineHandleIntercept = MineHandleIntercept()
val zhuHandleIntercept = ZhuHandleIntercept()
val maHandleIntercept = MaHandleIntercept()
val task = "绘制心电图"
/**
* 用if 或者是when 去执行 谁会这个技能 就取执行
*/
when (task) {
in mineHandleIntercept.technologyList() -> {
mineHandleIntercept.process(task)
}
in zhuHandleIntercept.technologyList() -> {
zhuHandleIntercept.process(task)
}
in maHandleIntercept.technologyList() -> {
maHandleIntercept.process(task)
}
}
}
很显然的结果是 肯定马总执行 打印以下接口
马总自己解决了绘制心电图
Process finished with exit code 0
按照 逻辑应用，应该我先开始执行任务，然后是朱工，然后在是 马总，需要形成一种链式调用，如果还成下面这种顺序，那马总永远帮我们做事了 比如 代码
/**
* 如果这个信息顺序错误 那马总把任务全干了
*/
when (task) {
in maHandleIntercept.technologyList() -> {
maHandleIntercept.process(task)
}
in zhuHandleIntercept.technologyList() -> {
zhuHandleIntercept.process(task)
}
in mineHandleIntercept.technologyList() -> {
mineHandleIntercept.process(task)
}
}
这种写法 是马总永远做了我们应该做的事情，这种写法完全不合理的，所以需要链式调用
在上面的代码基础上进行改版,首先基础接口改版成
abstract class HandleIntercept {
var nextHandle: HandleIntercept? = null
fun handleProcess(task: String) {
//如果技术列表存在 那就执行 不存在 链表下一个执行
if (technologyList().contains(task)) {
process(task)
} else {
//上一级别去执行这个任务
if (nextHandle != null) {
nextHandle?.handleProcess(task)
} else {
println("无人处理")
}
}
}
//任务
abstract fun process(task: String)
//技术列表
abstract fun technologyList(): List<String>
}
}
代码执行改版
val mineHandleIntercept:HandleIntercept = MineHandleIntercept()
val zhuHandleIntercept = ZhuHandleIntercept()
val maHandleIntercept = MaHandleIntercept()
//我的上一级是朱工
mineHandleIntercept.nextHandle = zhuHandleIntercept
//朱工上一级是马总
zhuHandleIntercept.nextHandle = maHandleIntercept
/**
* 所以要无论这个任务 要从我---朱工 --马总以此类推执行
*/
mineHandleIntercept.handleProcess(task)
执行结果
马总自己解决了绘制心电图
Process finished with exit code 0
上面模式改版成责任链模式！责任链的主要运用就是 每个节点 通过 类似 链表一样 联系在一起！以此类推去执行，直到这个任务有人执行 才能解决，但是现实业务逻辑当中 往往给这个不一样， 像 张总接到 一个项目，需要多个人去完成这个任务，把需要做这个任务的集合起来，一次类推去完成自己需要做的事！
这个就是无序，也可以做事不纯正的责任链模式
2，无序责任链模式
1，应用场景
okhttp 网络请求 ，获取java 拦截器模式都是无序
1,项目需求 张总接到一个项目，需要做Android Web 和后台，由谁做，是谁做，有朱工进行分配
网友评论