读书清单


我的书单

我习惯看纸质的书,但为了方便喜欢看电子版的朋友,这里也提供一些我所知道的电子版链接,不保证版本号都对,有的找不到(文末有他人推荐书单)


2017年(已购纸质书籍)


书籍照片 书名及电子书链接 简介和目录 读书笔记
javahexin 《java核心技术 卷1 第10版》 简介和目录 -
effjava 《effective java中文版 》(暂无电子版链接) 简介和目录 -
bianchengsixiang 《java编程思想 第四版 》 简介和目录 -
bingfahexin 《java并发编程核心方法与框架 》(暂无电子版链接) 简介和目录 -
bingfashizhan 《java并发编程实战 》(暂无电子版链接) 简介和目录 -
mianshi 《java面试宝典 》(暂无电子版链接) 简介和目录 -
javaweb 《深入分析java web技术内幕 》(暂无电子版链接) 简介和目录 -
javayouhua 《java性能优化权威指南 》(暂无电子版链接) 简介和目录 -
springrumen 《spring入门经典》(暂无电子版链接) 简介和目录 -
bootshizhan 《spring boot实战 》(暂无电子版链接) 简介和目录 -
mvczhinan 《spring mvc学习指南 》(暂无电子版链接) 简介和目录 -
maven 《maven实战 许晓斌著》 简介和目录 maven实战读书笔记分类
eclipse 《eclipse精粹 》(暂无电子版链接) 简介和目录 -
tomcat 《tomcat权威指南 》(暂无电子版链接) 简介和目录 -
shejimoshi1 《head first设计模式 》(暂无电子版链接) 简介和目录 -
shejimoshi2 《设计模式 》(暂无电子版链接) 简介和目录 设计模式读书笔记分类
bianma 《编码 CODE 》(暂无电子版链接) 简介和目录 -
redis 《redis开发与运维 付磊、张益军著》(暂无电子版链接) 简介和目录 -
mysqlrumen 《mysql从入门到精通 》(暂无电子版链接) 简介和目录 -

他人推荐书单

Lucida推荐程序员必读书单 1.0

博客在线推荐书单

江南白衣推荐书单1

江南白衣推荐书单2

小土刀书影音


已购书籍简介和目录


java核心技术

简介

Java领域最有影响力和价值的著作之一,由拥有20多年教学与研究经验的资深Java技术专家撰写(获Jolt大奖),与《Java编程思想》齐名,10余年全球畅销不衰,广受好评。第10版根据Java SE 8全面更新,同时修正了第9版中的不足,系统全面讲解了Java语言的核 心概念、语法、重要特性和开发方法,包含大量案例,实践性强。
一直以来,《Java核心技术》都被认为是面向高级程序员的经典教程和参考书,它内容翔实、客观准确,不拖泥带水,是想为实际应用编写健壮Java代码的程序员的首选。如今,本版进行了全面更新, 以反映近年来人们翘首以待、变革最大的Java版本(Java SE 8)的内容。这一版经过重写,并重新组织,全面阐释了新的Java SE 8特性、惯用法和佳实践,其中包含数百个示例程序,所有这些代码都经过精心设计,不仅易于理解,也很容易实际应用。
本书为专业程序员解决实际问题而写,可以帮助你深入了解Java语言和库。在卷I中,Horstmann主要强调基本语言概念和现代用户界面编程基础,深入介绍了从Java面向对象编程到泛型、集合、lambda表达式、Swing UI设计以及并发和函数式编程的
新方法等内容。

评价

https://book.douban.com/subject/26880667/

目录

第1章 Java程序设计概述 1
1.1 Java程序设计平台 1
1.2 Java“白皮书”的关键术语 2
1.2.1 简单性 2
1.2.2 面向对象 2
1.2.3 分布式 3
1.2.4 健壮性 3
1.2.5 安全性 3
1.2.6 体系结构中立 4
1.2.7 可移植性 4
1.2.8 解释型 5
1.2.9 高性能 5
1.2.10 多线程 5
1.2.11 动态性 5
1.3 Java applet与Internet 6
1.4 Java发展简史 7
1.5 关于Java的常见误解 9
第2章 Java程序设计环境 12
2.1 安装Java开发工具包 12
2.1.1 下载JDK 12
2.1.2 设置JDK 13
2.1.3 安装库源文件和文档 15
2.2 使用命令行工具 16
2.3 使用集成开发环境 18
2.4 运行图形化应用程序 21
2.5 构建并运行applet 23
第3章 Java的基本程序设计结构 28
3.1 一个简单的Java应用程序 28
3.2 注释 31
3.3 数据类型 32
3.3.1 整型 32
3.3.2 浮点类型 33
3.3.3 char类型 34
3.3.4 Unicode和char类型 35
3.3.5 boolean类型 35
3.4 变量 36
3.4.1 变量初始化 37
3.4.2 常量 37
3.5 运算符 38
3.5.1 数学函数与常量 39
3.5.2 数值类型之间的转换 40
3.5.3 强制类型转换 41
3.5.4 结合赋值和运算符 42
3.5.5 自增与自减运算符 42
3.5.6 关系和boolean运算符 42
3.5.7 位运算符 43
3.5.8 括号与运算符级别 44
3.5.9 枚举类型 45
3.6 字符串 45
3.6.1 子串 45
3.6.2 拼接 46
3.6.3 不可变字符串 46
3.6.4 检测字符串是否相等 47
3.6.5 空串与Null串 48
3.6.6 码点与代码单元 49
3.6.7 String API 50
3.6.8 阅读联机API文档 52
3.6.9 构建字符串 54
3.7 输入输出 55
3.7.1 读取输入 55
3.7.2 格式化输出 58
3.7.3 文件输入与输出 61
3.8 控制流程 63
3.8.1 块作用域 63
3.8.2 条件语句 63
3.8.3 循环 66
3.8.4 确定循环 69
3.8.5 多重选择:switch语句 72
3.8.6 中断控制流程语句 74
3.9 大数值 76
3.10 数组 78
3.10.1 for each循环 79
3.10.2 数组初始化以及匿名数组 80
3.10.3 数组拷贝 81
3.10.4 命令行参数 81
3.10.5 数组排序 82
3.10.6 多维数组 85
3.10.7 不规则数组 88
第4章 对象与类 91
4.1 面向对象程序设计概述 91
4.1.1 类 92
4.1.2 对象 93
4.1.3 识别类 93
4.1.4 类之间的关系 94
4.2 使用预定义类 95
4.2.1 对象与对象变量 95
4.2.2 Java类库中的LocalDate类 98
4.2.3 更改器方法与访问器方法 100
4.3 用户自定义类 103
4.3.1 Employee类 103
4.3.2 多个源文件的使用 105
4.3.3 剖析Employee类 106
4.3.4 从构造器开始 106
4.3.5 隐式参数与显式参数 108
4.3.6 封装的优点 109
4.3.7 基于类的访问权限 111
4.3.8 私有方法 111
4.3.9 final实例域 112
4.4 静态域与静态方法 112
4.4.1 静态域 112
4.4.2 静态常量 113
4.4.3 静态方法 114
4.4.4 工厂方法 115
4.4.5 main方法 115
4.5 方法参数 118
4.6 对象构造 123
4.6.1 重载 123
4.6.2 默认域初始化 123
4.6.3 无参数的构造器 124
4.6.4 显式域初始化 125
4.6.5 参数名 125
4.6.6 调用另一个构造器 126
4.6.7 初始化块 127
4.6.8 对象析构与finalize方法 130
4.7 包 131
4.7.1 类的导入 131
4.7.2 静态导入 133
4.7.3 将类放入包中 133
4.7.4 包作用域 136
4.8 类路径 137
4.8.1 设置类路径 139
4.9 文档注释 140
4.9.1 注释的插入 140
4.9.2 类注释 140
4.9.3 方法注释 141
4.9.4 域注释 142
4.9.5 通用注释 142
4.9.6 包与概述注释 143
4.9.7 注释的抽取 143
4.10 类设计技巧 144
第5章 继承 147
5.1 类、超类和子类 147
5.1.1 定义子类 147
5.1.2 覆盖方法 149
5.1.3 子类构造器 150
5.1.4 继承层次 153
5.1.5 多态 154
5.1.6 理解方法调用 155
5.1.7 阻止继承:final类和方法 157
5.1.8 强制类型转换 158
5.1.9 抽象类 160
5.1.10 受保护访问 165
5.2 Object:所有类的超类 166
5.2.1 equals方法 166
5.2.2 相等测试与继承 167
5.2.3 hashCode方法 170
5.2.4 toString方法 172
5.3 泛型数组列表 178
5.3.1 访问数组列表元素 180
5.3.2 类型化与原始数组列表的兼容性 183
5.4 对象包装器与自动装箱 184
5.5 参数数量可变的方法 187
5.6 枚举类 188
5.7 反射 190
5.7.1 Class类 190
5.7.2 捕获异常 192
5.7.3 利用反射分析类的能力 194
5.7.4 在运行时使用反射分析对象 198
5.7.5 使用反射编写泛型数组代码 202
5.7.6 调用任意方法 205
5.8 继承的设计技巧 208
第6章 接口、lambda表达式与内部类 211
6.1 接口 211
6.1.1 接口概念 211
6.1.2 接口的特性 217
6.1.3 接口与抽象类 218
6.1.4 静态方法 218
6.1.5 默认方法 219
6.1.6 解决默认方法冲突 220
6.2 接口示例 222
6.2.1 接口与回调 222
6.2.2 Comparator接口 224
6.2.3 对象克隆 225
6.3 lambda表达式 231
6.3.1 为什么引入lambda表达式 231
6.3.2 lambda表达式的语法 232
6.3.3 函数式接口 234
6.3.4 方法引用 235
6.3.5 构造器引用 237
6.3.6 变量作用域 237
6.3.7 处理lambda表达式 239
6.3.8 再谈Comparator 242
6.4 内部类 242
6.4.1 使用内部类访问对象状态 244
6.4.2 内部类的特殊语法规则 247
6.4.3 内部类是否有用、必要和安全 248
6.4.4 局部内部类 250
6.4.5 由外部方法访问变量 250
6.4.6 匿名内部类 252
6.4.7 静态内部类 255
6.5 代理 258
6.5.1 何时使用代理 259
6.5.2 创建代理对象 259
6.5.3 代理类的特性 262
第7章 异常、断言和日志 264
7.1 处理错误 264
7.1.1 异常分类 265
7.1.2 声明受查异常 267
7.1.3 如何抛出异常 269
7.1.4 创建异常类 270
7.2 捕获异常 271
7.2.1 捕获异常 271
7.2.2 捕获多个异常 273
7.2.3 再次抛出异常与异常链 274
7.2.4 finally子句 275
7.2.5 带资源的try语句 278
7.2.6 分析堆栈轨迹元素 280
7.3 使用异常机制的技巧 282
7.4 使用断言 285
7.4.1 断言的概念 285
7.4.2 启用和禁用断言 286
7.4.3 使用断言完成参数检查 287
7.4.4 为文档假设使用断言 288
7.5 记录日志 289
7.5.1 基本日志 289
7.5.2 高级日志 289
7.5.3 修改日志管理器配置 291
7.5.4 本地化 292
7.5.5 处理器 293
7.5.6 过滤器 296
7.5.7 格式化器 296
7.5.8 日志记录说明 296
7.6 调试技巧 304
第8章 泛型程序设计 309
8.1 为什么要使用泛型程序设计 309
8.1.1 类型参数的好处 309
8.1.2 谁想成为泛型程序员 310
8.2 定义简单泛型类 311
8.3 泛型方法 313
8.4 类型变量的限定 314
8.5 泛型代码和虚拟机 316
8.5.1 类型擦除 316
8.5.2 翻译泛型表达式 317
8.5.3 翻译泛型方法 318
8.5.4 调用遗留代码 319
8.6 约束与局限性 320
8.6.1 不能用基本类型实例化类型参数 320
8.6.2 运行时类型查询只适用于原始类型 321
8.6.3 不能创建参数化类型的数组 321
8.6.4 Varargs警告 322
8.6.5 不能实例化类型变量 323
8.6.6 不能构造泛型数组 323
8.6.7 泛型类的静态上下文中类型变量无效 325
8.6.8 不能抛出或捕获泛型类的实例 325
8.6.9 可以消除对受查异常的检查 326
8.6.10 注意擦除后的冲突 327
8.7 泛型类型的继承规则 328
8.8 通配符类型 330
8.8.1 通配符概念 330
8.8.2 通配符的超类型限定 331
8.8.3 无限定通配符 334
8.8.4 通配符捕获 334
8.9 反射和泛型 337
8.9.1 泛型Class类 337
8.9.2 使用Class参数进行类型匹配 338
8.9.3 虚拟机中的泛型类型信息 338
第9章 集合 344
9.1 Java集合框架 344
9.1.1 将集合的接口与实现分离 344
9.1.2 Collection接口 346
9.1.3 迭代器 347
9.1.4 泛型实用方法 349
9.1.5 集合框架中的接口 352
9.2 具体的集合 353
9.2.1 链表 355
9.2.2 数组列表 362
9.2.3 散列集 363
9.2.4 树集 366
9.2.5 队列与双端队列 369
9.2.6 优先级队列 371
9.3 映射 372
9.3.1 基本映射操作 372
9.3.2 更新映射项 375
9.3.3 映射视图 376
9.3.4 弱散列映射 377
9.3.5 链接散列集与映射 378
9.3.6 枚举集与映射 379
9.3.7 标识散列映射 380
9.4 视图与包装器 381
9.4.1 轻量级集合包装器 382
9.4.2 子范围 382
9.4.3 不可修改的视图 383
9.4.4 同步视图 384
9.4.5 受查视图 384
9.4.6 关于可选操作的说明 385
9.5 算法 388
9.5.1 排序与混排 389
9.5.2 二分查找 391
9.5.3 简单算法 392
9.5.4 批操作 394
9.5.5 集合与数组的转换 394
9.5.6 编写自己的算法 395
9.6 遗留的集合 396
9.6.1 Hashtable类 397
9.6.2 枚举 397
9.6.3 属性映射 398
9.6.4 栈 399
9.6.5 位集 399
第10章 图形程序设计 403
10.1 Swing概述 403
10.2 创建框架 407
10.3 框架定位 409
10.3.1 框架属性 411
10.3.2 确定合适的框架大小 411
10.4 在组件中显示信息 415
10.5 处理2D图形 419
10.6 使用颜色 426
10.7 文本使用特殊字体 429
10.8 显示图像 435
第11章 事件处理 439
11.1 事件处理基础 439
11.1.1 实例:处理按钮点击事件 441
11.1.2 简洁地指定监听器 445
11.1.3 实例:改变观感 447
11.1.4 适配器类 450
11.2 动作 453
11.3 鼠标事件 459
11.4 AWT事件继承层次 465
11.4.1 语义事件和底层事件 466
第12章 Swing用户界面组件 469
12.1 Swing和模型–视图–控制器设计模式 469
12.1.1 设计模式 469
12.1.2 模型–视图–控制器模式 470
12.1.3 Swing按钮的模型–视图–控制器分析 473
12.2 布局管理概述 474
12.2.1 边框布局 477
12.2.2 网格布局 478
12.3 文本输入 481
12.3.1 文本域 482
12.3.2 标签和标签组件 483
12.3.3 密码域 484
12.3.4 文本区 485
12.3.5 滚动窗格 485
12.4 选择组件 488
12.4.1 复选框 488
12.4.2 单选钮 490
12.4.3 边框 493
12.4.4 组合框 496
12.4.5 滑动条 499
12.5 菜单 504
12.5.1 菜单创建 504
12.5.2 菜单项中的图标 507
12.5.3 复选框和单选钮菜单项 508
12.5.4 弹出菜单 508
12.5.5 快捷键和加速器 510
12.5.6 启用和禁用菜单项 511
12.5.7 工具栏 515
12.5.8 工具提示 516
12.6 复杂的布局管理 518
12.6.1 网格组布局 520
12.6.2 组布局 528
12.6.3 不使用布局管理器 537
12.6.4 定制布局管理器 537
12.6.5 遍历顺序 541
12.7 对话框 541
12.7.1 选项对话框 542
12.7.2 创建对话框 551
12.7.3 数据交换 554
12.7.4 文件对话框 559
12.7.5 颜色选择器 569
12.8 GUI程序排错 573
12.8.1 调试技巧 573
12.8.2 让AWT机器人完成工作 576
第13章 部署Java应用程序 580
13.1 JAR文件 580
13.1.1 创建JAR文件 580
13.1.2 清单文件 581
13.1.3 可执行JAR文件 582
13.1.4 资源 583
13.1.5 密封 585
13.2 应用首选项的存储 586
13.2.1 属性映射 586
13.2.2 首选项API 591
13.3 服务加载器 596
13.4 applet 598
13.4.1 一个简单的applet 599
13.4.2 applet HTML标记和属性 602
13.4.3 使用参数向applet传递信息 603
13.4.4 访问图像和音频文件 608
13.4.5 applet上下文 609
13.4.6 applet间通信 609
13.4.7 在浏览器中显示信息项 610
13.4.8 沙箱 611
13.4.9 签名代码 612
13.5 Java Web Start 614
13.5.1 发布Java Web Start应用 614
13.5.2 JNLP API 617
第14章 并发 624
14.1 什么是线程 624
14.1.1 使用线程给其他任务提供机会 629
14.2 中断线程 632
14.3 线程状态 635
14.3.1 新创建线程 635
14.3.2 可运行线程 635
14.3.3 被阻塞线程和等待线程 636
14.3.4 被终止的线程 636
14.4 线程属性 638
14.4.1 线程优先级 638
14.4.2 守护线程 639
14.4.3 未捕获异常处理器 639
14.5 同步 640
14.5.1 竞争条件的一个例子 641
14.5.2 竞争条件详解 644
14.5.3 锁对象 646
14.5.4 条件对象 648
14.5.5 synchronized关键字 653
14.5.6 同步阻塞 656
14.5.7 监视器概念 657
14.5.8 Volatile域 658
14.5.9 final变量 659
14.5.10 原子性 659
14.5.11 死锁 661
14.5.12 线程局部变量 663
14.5.13 锁测试与超时 665
14.5.14 读/写锁 666
14.5.15 为什么弃用stop和suspend方法 667
14.6 阻塞队列 668
14.7 线程安全的集合 673
14.7.1 高效的映射、集和队列 674
14.7.2 映射条目的原子更新 675
14.7.3 对并发散列映射的批操作 676
14.7.4 并发集视图 678
14.7.5 写数组的拷贝 679
14.7.6 并行数组算法 679
14.7.7 较早的线程安全集合 680
14.8 Callable与Future 681
14.9 执行器 685
14.9.1 线程池 685
14.9.2 预定执行 689
14.9.3 控制任务组 690
14.9.4 Fork-Join框架 691
14.9.5 可完成Future 694
14.10 同步器 696
14.10.1 信号量 696
14.10.2 倒计时门栓 697
14.10.3 障栅 697
14.10.4 交换器 698
14.10.5 同步队列 698
14.11 线程与Swing 698
14.11.1 运行耗时的任务 699
14.11.2 使用Swing工作线程 703
14.11.3 单一线程规则 708


effectivejava中文版

简介

本书介绍了在Java编程中78条极具实用价值的经验规则,这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。通过对Java平台设计专家所使用的技术的全面描述,揭示了应该做什么,不应该做什么才能产生清晰、健壮和高效的代码。
本书中的每条规则都以简短、独立的小文章形式出现,并通过例子代码加以进一步说明。本书内容全面,结构清晰,讲解详细。可作为技术人员的参考用书。

评价

https://book.douban.com/subject/3360807/

目录

第1章 引言
第2章 创建和销毁对象
第1条:考虑用静态工厂方法代替构造器
第2条:遇到多个构造器参数时要考虑用构建器
第3条:用私有构造器或者枚举类型强化Singleton属性
第4条:通过私有构造器强化不可实例化的能力
第5条:避免创建不必要的对象
第6条:消除过期的对象引用
第7条:避免使用终结方法
第3章 对于所有对象都通用的方法
第8条:覆盖equals时请遵守通用约定
第9条:覆盖equals时总要覆盖hashCode
第10条:始终要覆盖toString
第11条:谨慎地覆盖clone
第12条:考虑实现Comparable接口
第4章 类和接口
第13条:使类和成员的可访问性最小化
第14条:在公有类中使用访问方法而非公有域
第15条:使可变性最小化
第16条:复合优先于继承
第17条:要么为继承而设计,并提供文档说明,要么就禁止继承
第18条:接口优于抽象类
第19条:接口只用于定义类型
第20条:类层次优于标签类
第21条:用函数对象表示策略
第22条:优先考虑静态成员类
第5章 泛型
第23条:请不要在新代码中使用原生态类型
第24条:消除非受检警告
第25条:列表优先于数组
第26条:优先考虑泛型
第27条:优先考虑泛型方法
第28条:利用有限制通配符来提升API的灵活性
第29条:优先考虑类型安全的异构容器
第6章 枚举和注解
第30条:用enum代替int常量
第31条:用实例域代替序数
第32条:用EnumSet代替位域
第33条:用EnumMap代替序数索引
第34条:用接口模拟可伸缩的枚举
第35条:注解优先于命名模式
第36条:坚持使用Override注解
第37条:用标记接口定义类型
第7章 方法
第38条:检查参数的有效性
第39条:必要时进行保护性拷贝
第40条:谨慎设计方法签名
第41条:慎用重载
第42条:慎用可变参数
第43条:返回零长度的数组或者集合,而不是:null
第44条:为所有导出的API元素编写文档注释
第8章 通用程序设计
第45条:将局部变量的作用域最小化
第46条:for-each循环优先于传统的for循环
第47条:了解和使用类库
第48条:如果需要精确的答案,请避免使用float和double
第49条:基本类型优先于装箱基本类型
第50条:如果其他类型更适合,则尽量避免使用字符串
第51条:当心字符串连接的性能
第52条:通过接口引用对象
第53条:接口优先于反射机制
第54条:谨慎地使用本地方法
第55条:谨慎地进行优化
第56条:遵守普遍接受的命名惯例
第9章 异常
第57条:只针对异常的情况才使用异常
第58条:对可恢复的情况使用受检异常,对编程错误使用运行时异常
第59条:避免不必要地使用受检的异常
第60条:优先使用标准的异常
第61条:抛出与抽象相对应的异常
第62条:每个方法抛出的异常都要有文档
第63条:在细节消息中包含能捕获失败的信息
第64条:努力使失败保持原子性
第65条:不要忽略异常
第10章 并发
第66条:同步访问共享的可变数据
第67条:避免过度同步
第68条:executor和task优先干线程
第69条:并发工具优先于wait和notify
第70条:线程安全性的文档化
第71条:慎用延迟初始化
第72条:不要依赖于线程调度器
第73条:避免使用线程组
第11章 序列化
第74条:谨慎地实现Serializable接口
第75条:考虑使用自定义的序列化形式
第76条:保护性地编写readObject方法
第77条:对于实例控制,枚举类型优先于readResolve
第78条:考虑用序列化代理代替序列化实例


java编程思想

简介

本书赢得了全球程序员的广泛赞誉,即使是最晦涩的概念,在Bruce Eckel的文字亲和力和小而直接的编程示例面前也会化解于无形。从Java的基础语法到最高级特性(深入的面向对象概念、多线程、自动项目构建、单元测试和调试等),本书都能逐步指导你轻松掌握。
从本书获得的各项大奖以及来自世界各地的读者评论中,不难看出这是一本经典之作。本书的作者拥有多年教学经验,对C、C++以及Java语言都有独到、深入的见解,以通俗易懂及小而直接的示例解释了一个个晦涩抽象的概念。本书共22章,包括操作符、控制执行流程、访问权限控制、复用类、多态、接口、通过异常处理错误、字符串、泛型、数组、容器深入研究、Java I/O系统、枚举类型、并发以及图形化用户界面等内容。这些丰富的内容,包含了Java语言基础语法以及高级特性,适合各个层次的Java程序员阅读,同时也是高等院校讲授面向对象程序设计语言以及Java语言的绝佳教材和参考书。
第4版特点:
适合初学者与专业人员的经典的面向对象叙述方式,为更新的Java SE5/6增加了新的示例和章节。
测验框架显示程序输出。

评价

https://book.douban.com/subject/2130190/

目录

第1章 对象导论
1.1 抽象过程
1.2 每个对象都有一个接口
1.3 每个对象都提供服务
1.4 被隐藏的具体实现
1.5 复用具体实现
1.6 继承
1.6.1 “是一个”(is-a)与“像是一个”(is-like-a)关系
1.7 伴随多态的可互换对象
1.8 单根继承结构
1.9 容器
1.9.1 参数化类型(范型)
1.10 对象的创建和生命期
1.11 异常处理:处理错误
1.12 并发编程
1.13 Java与Internet
1.13.1 Web是什么
1.13.2 客户端编程
1.13.3 服务器端编程
1.22 总结
第2章 一切都是对象
2.1 用引用操纵对象
2.2 必须由你创建所有对象
2.2.1 存储到什么地方
2.2.2 特例:基本类型
2.2.3 Java中的数组
2.3 永远不需要销毁对象
2.3.1 作用域
2.3.2 对象的作用域
2.4 创建新的数据类型:类
2.4.1 域和方法
2.4.2 基本成员默认值
2.5 方法、参数和返回值
2.5.1 参数列表
2.6 构建一个Java程序
2.6.1 名字可见性
2.6.2 运用其他构件
2.6.3 static 关键字
2.7 你的第一个Java程序
编译和运行
2.8 注释和嵌入式文档
2.8.1 注释文档
2.8.2 语法
2.8.3 嵌入式HTML
2.8.4 一些标签示例
2.8.5 文档示例
2.9 编码风格
2.10 总结
2.11 练习
第3章 操作符
3.1 更简单的打印语句
3.2 使用Java操作符
3.3 优先级
3.4 赋值
3.4.1 方法调用中的别名问题
3.5 算术操作符
3.5.1 一元加、减操作符
3.6 自动递增和递减
3.7 关系操作符
3.7.1 测试对象的等价性
3.8 逻辑操作符
3.8.1 短路
3.9 直接常量
3.9.1 指数记数法
3.10 按位操作符
3.11 移位操作符
3.12 三元操作符 if-else
3.13 字符串操作符 + 和 +=
3.14 使用操作符时常犯的错误
3.15 类型转换操作符
3.15.1 截尾和舍入
3.15.2提升
3.16 Java没有“sizeof”
3.17 操作符小结
3.18 总结
第4章 控制执行流程
4.1 true和false
4.2 if-else
4.3 迭代
4.3.1 do-while
4.3.2 for
4.3.3 逗号操作符
4.4 Foreach语法
4.5 return
4.6 break和 continue
4.7 臭名昭著的“goto”
4.8 switch
4.9 总结
第5章 初始化与清理
5.1 用构造器确保初始化
5.2 方法重载
5.2.1 区分重载方法
5.2.2 涉及基本类型的重载
5.2.3 以返回值区分重载方法
5.3 缺省构造器
5.4 this关键字
5.4.1 在构造器中调用构造器
5.4.2 static的含义
5.5 清理:终结处理和垃圾回收
5.5.1 finalize()的用途何在
5.5.2 你必须实施清理
5.5.3 终结条件
5.5.4 垃圾回收器如何工作
5.6 成员初始化
5.6.1 指定初始化
5.7 构造器初始化
5.7.1 初始化顺序
5.7.2. 静态数据的初始化
5.7.3. 显式的静态初始化
5.7.4. 非静态实例初始化
5.8 数组初始化
5.8.1 可变参数列表
5.9 枚举类型
5.10 总结
第6章 访问权限控制
第7章 复用类
第8章 多态
第9章 接口
第10章 内部类
第11章 持有对象
第12章 通过异常处理错误
第13章 字符串
第14章 类型信息
第15章 泛型
第16章 数组
第17章 容器深入研究
第18章 Java I/O系统
第19章 枚举类型
第20章 注解
第21章 并发
第22章 图形化用户界面


java并发编程核心方法与框架

简介

本书主要介绍非常核心并常用的技术点,比如解决高并发环境下的线程间同步问题,可以使用Semaphore,CountDownLatch,CyclicBarrier以及Phaser类来解决,还要掌握线程池ThreadPoolExecutor的使用,还有线程池结合计划任务ScheduledExecutorService接口的使用,Future接口的使用,CompletionService异步任务的使用,ExecutorService工具接口的使用,Fork-Join分治编程的学习和Java技术中使用率比较高的并发集合框架。

评价

https://book.douban.com/subject/26859317/

目录

第1章 Semaphore和Exchanger的使用 1
1.1 Semaphore的使用 2
1.1.1 类Semaphore的同步性 2
1.1.2 类Semaphore构造方法permits参数作用 4
1.1.3 方法acquire(int permits)参数作用及动态添加permits许可数量 5
1.1.4 方法acquireUninterruptibly()的使用 8
1.1.5 方法availablePermits()和drainPermits() 10
1.1.6 方法getQueueLength()和hasQueuedThreads() 12
1.1.7 公平与非公平信号量的测试 13
1.1.8 方法tryAcquire()的使用 15
1.1.9 方法tryAcquire(int permits)的使用 17
1.1.10 方法tryAcquire(long timeout, TimeUnit unit)的使用 17
1.1.11 方法tryAcquire(int permits, long timeout, TimeUnit unit)的使用 19
1.1.12 多进路-多处理-多出路实验 20
1.1.13 多进路-单处理-多出路实验 21
1.1.14 使用Semaphore创建字符串池 23
1.1.15 使用Semaphore实现多生产者/多消费者模式 25
1.2 Exchanger的使用 31
1.2.1 方法exchange()阻塞的特性 31
1.2.2 方法exchange()传递数据 32
1.2.3 方法exchange(V x, long timeout, TimeUnit unit)与超时 34
1.3 本章总结 35
第2章 CountDownLatch和CyclicBarrier的使用 36
2.1 CountDownLatch的使用 36
2.1.1 初步使用 37
2.1.2 裁判在等全部的运动员到来 38
2.1.3 各就各位准备比赛 39
2.1.4 完整的比赛流程 41
2.1.5 方法await(long timeout, TimeUnit unit) 44
2.1.6 方法getCount()的使用 46
2.2 CyclicBarrier的使用 46
2.2.1 初步使用 48
2.2.2 验证屏障重置性及getNumberWaiting()方法的使用 51
2.2.3 用CyclicBarrier类实现阶段跑步比赛 52
2.2.4 方法isBroken()的使用 55
2.2.5 方法await(long timeout, TimeUnit unit)超时出现异常的测试 57
2.2.6 方法getNumberWaiting()和getParties() 60
2.2.7 方法reset() 62
2.3 本章总结 64
第3章 Phaser的使用 65
3.1 Phaser的使用 66
3.2 类Phaser的arriveAndAwaitAdvance()方法测试1 66
3.3 类Phaser的arriveAndAwaitAdvance()方法测试2 68
3.4 类Phaser的arriveAndDeregister()方法测试 69
3.5 类Phaser的getPhase()和onAdvance()方法测试 70
3.6 类Phaser的getRegisteredParties()方法和register()测试 74
3.7 类Phaser的bulkRegister()方法测试 75
3.8 类Phaser的getArrivedParties()和getUnarrivedParties()方法测试 75
3.9 类Phaser的arrive()方法测试1 77
3.10 类Phaser的arrive ()方法测试2 78
3.11 类Phaser的awaitAdvance(int phase)方法测试 81
3.12 类Phaser的awaitAdvanceInterruptibly(int)方法测试1 83
3.13 类Phaser的awaitAdvanceInterruptibly(int)方法测试2 84
3.14 类Phaser的awaitAdvanceInterruptibly(int)方法测试3 86
3.15 类Phaser的awaitAdvanceInterruptibly(int,long,TimeUnit)方法测试4 87
3.16 类Phaser的forceTermination()和isTerminated()方法测试 89
3.17 控制Phaser类的运行时机 92
3.18 本章总结 93
第4章 Executor与ThreadPoolExecutor的使用 94
4.1 Executor接口介绍 94
4.2 使用Executors工厂类创建线程池 97
4.2.1 使用newCachedThreadPool()方法创建无界线程池 98
4.2.2 验证newCachedThreadPool()创建为Thread池 100
4.2.3 使用newCachedThreadPool (ThreadFactory)定制线程工厂 102
4.2.4 使用newFixedThreadPool(int)方法创建有界线程池 103
4.2.5 使用newFixedThreadPool(int, ThreadFactory)定制线程工厂 105
4.2.6 使用newSingleThreadExecutor()方法创建单一线程池 106
4.2.7 使用newSingleThreadExecutor(ThreadFactory)定制线程工厂 107
4.3 ThreadPoolExecutor的使用 107
4.3.1 构造方法的测试 107
4.3.2 方法shutdown()和shutdownNow()与返回值 119
4.3.3 方法isShutdown() 129
4.3.4 方法isTerminating ()和isTerminated () 129
4.3.5 方法awaitTermination(long timeout,TimeUnit unit) 131
4.3.6 工厂ThreadFactory+execute()+UncaughtExceptionHandler处理异常 134
4.3.7 方法set/getRejectedExecutionHandler() 138
4.3.8 方法allowsCoreThreadTimeOut()/(boolean) 140
4.3.9 方法prestartCoreThread()和prestartAllCoreThreads() 142
4.3.10 方法getCompletedTaskCount() 144
4.3.11 常见3种队列结合max值的因果效果 145
4.3.12 线程池ThreadPoolExecutor的拒绝策略 151
4.3.13 方法afterExecute()和beforeExecute() 157
4.3.14 方法remove(Runnable)的使用 159
4.3.15 多个get方法的测试 162
4.3.16 线程池ThreadPoolExecutor与Runnable执行为乱序特性 166
4.4 本章总结 167
第5章 Future和Callable的使用 168
5.1 Future和Callable的介绍 168
5.2 方法get()结合ExecutorService中的submit(Callable)的使用 168
5.3 方法get()结合ExecutorService中的submit(Runnable)和isDone()的使用 170
5.4 使用ExecutorService接口中的方法submit(Runnable, T result) 170
5.5 方法cancel(boolean mayInterruptIfRunning)和isCancelled()的使用 173
5.6 方法get(long timeout, TimeUnit unit)的使用 178
5.7 异常的处理 179
5.8 自定义拒绝策略RejectedExecutionHandler接口的使用 181
5.9 方法execute()与submit()的区别 182
5.10 验证Future的缺点 186
5.11 本章总结 188
第6章 CompletionService的使用 189
6.1 CompletionService介绍 189
6.2 使用CompletionService解决Future的缺点 190
6.3 使用take()方法 193
6.4 使用poll()方法 194
6.5 使用poll(long timeout, TimeUnit unit)方法 195
6.6 类CompletionService与异常 199
6.7 方法Future submit(Runnable task, V result)的测试 205
6.8 本章总结 207
第7章 接口ExecutorService的方法使用 208
7.1 在ThreadPoolExecutor中使用ExecutorService中的方法 208
7.2 方法invokeAny(Collection tasks)的使用与interrupt 209
7.3 方法invokeAny()与执行慢的任务异常 212
7.4 方法invokeAny()与执行快的任务异常 216
7.5 方法invokeAny()与全部异常 220
7.6 方法invokeAny(CollectionTasks, timeout, timeUnit)超时的测试 222
7.7 方法invokeAll(Collection tasks)全正确 226
7.8 方法invokeAll(Collection tasks)快的正确慢的异常 227
7.9 方法invokeAll(Collection tasks)快的异常慢的正确 230
7.10 方法invokeAll(Collection tasks,long timeout,TimeUnit unit)先慢后快 232
7.11 方法invokeAll(Collection tasks,long timeout,TimeUnit unit)先快后慢 234
7.12 方法invokeAll(Collection tasks,long timeout,TimeUnit unit)全慢 236
7.13 本章总结 238
第8章 计划任务ScheduledExecutorService的使用 239
8.1 ScheduledExecutorService的使用 240
8.2 ScheduledThreadPoolExecutor使用Callable延迟运行 241
8.3 ScheduledThreadPoolExecutor使用Runnable延迟运行 244
8.4 延迟运行并取得返回值 245
8.5 使用scheduleAtFixedRate()方法实现周期性执行 246
8.6 使用scheduleWithFixedDelay()方法实现周期性执行 248
8.7 使用getQueue()与remove()方法 250
8.8 方法setExecuteExistingDelayedTasksAfterShutdownPolicy()的使用 253
8.9 方法setContinueExistingPeriodicTasksAfterShutdownPolicy() 255
8.10 使用cancel(boolean)与setRemoveOnCancelPolicy()方法 257
8.11 本章总结 261
第9章 Fork-Join分治编程 262
9.1 Fork-Join分治编程与类结构 262
9.2 使用RecursiveAction让任务跑起来 264
9.3 使用RecursiveAction分解任务 265
9.4 使用RecursiveTask取得返回值与join()和get()方法的区别 266
9.5 使用RecursiveTask执行多个任务并打印返回值 270
9.6 使用RecursiveTask实现字符串累加 272
9.7 使用Fork-Join实现求和:实验1 273
9.8 使用Fork-Join实现求和:实验2 275
9.9 类ForkJoinPool核心方法的实验 276
9.9.1 方法public void execute(ForkJoinTask task)的使用 276
9.9.2 方法public void execute(Runnable task)的使用 278
9.9.3 方法public void execute(ForkJoinTask task)如何处理返回值 278
9.9.4 方法public ForkJoinTask submit(ForkJoinTask task)的使用 279
9.9.5 方法public ForkJoinTask submit(Runnable task)的使用 280
9.9.6 方法public ForkJoinTask submit(Callable task)的使用 281
9.9.7 方法public ForkJoinTask submit(Runnable task, T result)的使用 282
9.9.8 方法public List] invokeAll(Collection] tasks)的使用 285
9.9.9 方法public void shutdown()的使用 286
9.9.10 方法public List shutdownNow()的使用 289
9.9.11 方法isTerminating()和isTerminated()的使用 292
9.9.12 方法public boolean isShutdown()的使用 295
9.9.13 方法public boolean awaitTermination(long timeout, TimeUnit unit)的使用 297
9.9.14 方法public T invoke(ForkJoinTask task)的使用 299
9.9.15 监视pool池的状态 301
9.10 类ForkJoinTask对异常的处理 308
9.11 本章总结 309
第10章 并发集合框架 310
10.1 集合框架结构简要 310
10.1.1 接口Iterable 310
10.1.2 接口Collection 311
10.1.3 接口List 311
10.1.4 接口Set 312
10.1.5 接口Queue 312
10.1.6 接口Deque 312
10.2 非阻塞队列 313
10.2.1 类ConcurrentHashMap的使用 313
10.2.2 类ConcurrentSkipListMap的使用 322
10.2.3 类ConcurrentSkipListSet的使用 325
10.2.4 类ConcurrentLinkedQueue的使用 328
10.2.5 类ConcurrentLinkedDeque的使用 330
10.2.6 类CopyOnWriteArrayList的使用 332
10.2.7 类CopyOnWriteArraySet的使用 335
10.3 阻塞队列 337
10.3.1 类ArrayBlockingQueue的使用 337
10.3.2 类PriorityBlockingQueue的使用 338
10.3.3 类LinkedBlockingQueue的使用 340
10.3.4 类LinkedBlockingDeque的使用 341
10.3.5 类SynchronousQueue的使用 341
10.3.6 类DelayQueue的使用 344
10.3.7 类LinkedTransferQueue的使用 345
10.4 本章总结 354


java并发编程实战

简介

本书深入浅出地介绍了Java线程和并发,是一本完美的Java并发参考手册。书中从并发性和线程安全性的基本概念出发,介绍了如何使用类库提供的基本并发构建块,用于避免并发危险、构造线程安全的类及验证线程安全的规则,如何将小的线程安全类组合成更大的线程安全类,如何利用线程来提高并发应用程序的吞吐量,如何识别可并行执行的任务,如何提高单线程子系统的响应性,如何确保并发程序执行预期任务,如何提高并发代码的性能和可伸缩性等内容,最后介绍了一些高级主题,如显式锁、原子变量、非阻塞算法以及如何开发自定义的同步工具类。
本书适合Java程序开发人员阅读。

评价

https://book.douban.com/subject/10484692/

目录

第1章 简介1
1.1 并发简史1
1.2 线程的优势2
1.2.1 发挥多处理器的强大能力2
1.2.2 建模的简单性3
1.2.3 异步事件的简化处理3
1.2.4 响应更灵敏的用户界面4
1.3 线程带来的风险4
1.3.1 安全性问题5
1.3.2 活跃性问题7
1.3.3 性能问题7
1.4 线程无处不在7
第一部分 基础知识
第2章 线程安全性11
2.1 什么是线程安全性13
2.2 原子性14
2.2.1 竞态条件15
2.2.2 示例:延迟初始化中的竞态条件16
2.2.3 复合操作17
2.3 加锁机制18
2.3.1 内置锁20
2.3.2 重入21
2.4 用锁来保护状态22
2.5 活跃性与性能23
第3章 对象的共享27
3.1 可见性27
3.1.1 失效数据28
3.1.2 非原子的64位操作29
3.1.3 加锁与可见性30
3.1.4 Volatile变量 30
3.2 发布与逸出32
3.3 线程封闭35
3.3.1 Ad-hoc线程封闭35
3.3.2 栈封闭36
3.3.3 ThreadLocal类37
3.4 不变性38
3.4.1 Final域39
3.4.2 示例:使用Volatile类型来发布不可变对象40
3.5 安全发布41
3.5.1 不正确的发布:正确的对象被破坏42
3.5.2  不可变对象与初始化安全性42
3.5.3 安全发布的常用模式43
3.5.4 事实不可变对象44
3.5.5 可变对象44
3.5.6 安全地共享对象44
第4章 对象的组合46
4.1 设计线程安全的类46
4.1.1 收集同步需求47
4.1.2 依赖状态的操作48
4.1.3 状态的所有权48
4.2 实例封闭49
4.2.1 Java监视器模式51
4.2.2 示例:车辆追踪51
4.3 线程安全性的委托53
4.3.1 示例:基于委托的车辆追踪器54
4.3.2 独立的状态变量55
4.3.3 当委托失效时56
4.3.4 发布底层的状态变量57
4.3.5 示例:发布状态的车辆追踪器58
4.4 在现有的线程安全类中添加功能59
4.4.1 客户端加锁机制60
4.4.2 组合62
4.5 将同步策略文档化62
第5章 基础构建模块66
5.1 同步容器类66
5.1.1 同步容器类的问题66
5.1.2 迭代器与Concurrent-ModificationException68
5.1.3 隐藏迭代器69
5.2 并发容器70
5.2.1 ConcurrentHashMap71
5.2.2 额外的原子Map操作72
5.2.3 CopyOnWriteArrayList72
5.3 阻塞队列和生产者-消费者模式73
5.3.1 示例:桌面搜索75
5.3.2 串行线程封闭76
5.3.3 双端队列与工作密取77
5.4 阻塞方法与中断方法77
5.5 同步工具类78
5.5.1 闭锁79
5.5.2 FutureTask80
5.5.3 信号量82
5.5.4 栅栏83
5.6 构建高效且可伸缩的结果缓存85
第二部分 结构化并发应用程序
第6章 任务执行93
6.1 在线程中执行任务93
6.1.1 串行地执行任务94
6.1.2 显式地为任务创建线程94
6.1.3 无限制创建线程的不足95
6.2 Executor框架96
6.2.1 示例:基于Executor的Web服务器97
6.2.2 执行策略98
6.2.3 线程池98
6.2.4 Executor的生命周期99
6.2.5 延迟任务与周期任务101
6.3 找出可利用的并行性102
6.3.1 示例:串行的页面渲染器102
6.3.2 携带结果的任务Callable与Future103
6.3.3 示例:使用Future实现页面渲染器104
6.3.4 在异构任务并行化中存在的局限106
6.3.5 CompletionService:Executor与BlockingQueue106
6.3.6 示例:使用CompletionService实现页面渲染器107
6.3.7 为任务设置时限108
6.3.8 示例:旅行预定门户网站109
第7章 取消与关闭111
7.1 任务取消111
7.1.1 中断113
7.1.2 中断策略116
7.1.3 响应中断117
7.1.4 示例:计时运行118
7.1.5 通过Future来实现取消120
7.1.6 处理不可中断的阻塞121
7.1.7 采用newTaskFor来封装非标准的取消122
7.2 停止基于线程的服务124
7.2.1 示例:日志服务124
7.2.2 关闭ExecutorService127
7.2.3 “毒丸”对象128
7.2.4 示例:只执行一次的服务129
7.2.5 shutdownNow的局限性130
7.3 处理非正常的线程终止132
7.4 JVM关闭135
7.4.1 关闭钩子135
7.4.2 守护线程136
7.4.3 终结器136
第8章 线程池的使用138
8.1 在任务与执行策略之间的隐性耦合138
8.1.1 线程饥饿死锁139
8.1.2 运行时间较长的任务140
8.2 设置线程池的大小140
8.3 配置ThreadPoolExecutor141
8.3.1 线程的创建与销毁142
8.3.2 管理队列任务142
8.3.3 饱和策略144
8.3.4 线程工厂146
8.3.5 在调用构造函数后再定制ThreadPoolExecutor147
8.4 扩展 ThreadPoolExecutor148
8.5 递归算法的并行化149
第9章 图形用户界面应用程序156
9.1 为什么GUI是单线程的156
9.1.1 串行事件处理157
9.1.2 Swing中的线程封闭机制158
9.2 短时间的GUI任务160
9.3 长时间的GUI任务161
9.3.1 取消162
9.3.2 进度标识和完成标识163
9.3.3 SwingWorker165
9.4 共享数据模型165
9.4.1 线程安全的数据模型166
9.4.2 分解数据模型166
9.5 其他形式的单线程子系统167
第三部分 活跃性、性能与测试
第10章 避免活跃性危险169
10.1 死锁169
10.1.1 锁顺序死锁170
10.1.2 动态的锁顺序死锁171
10.1.3 在协作对象之间发生的死锁174
10.1.4 开放调用175
10.1.5 资源死锁177
10.2 死锁的避免与诊断178
10.2.1 支持定时的锁178
10.2.2 通过线程转储信息来分析死锁178
10.3 其他活跃性危险180
10.3.1 饥饿180
10.3.2 糟糕的响应性181
10.3.3 活锁181
第11章 性能与可伸缩性183
11.1 对性能的思考183
11.1.1 性能与可伸缩性184
11.1.2 评估各种性能权衡因素185
11.2 Amdahl定律186
11.2.1 示例:在各种框架中隐藏的串行部分188
11.2.2 Amdahl定律的应用189
11.3 线程引入的开销189
11.3.1 上下文切换190
11.3.2 内存同步190
11.3.3 阻塞192
11.4 减少锁的竞争192
11.4.1 缩小锁的范围(“快进快出”)193
11.4.2 减小锁的粒度195
11.4.3 锁分段196
11.4.4 避免热点域197
11.4.5 一些替代独占锁的方法198
11.4.6 监测CPU的利用率199
11.4.7 向对象池说“不”200
11.5 示例:比较Map的性能200
11.6 减少上下文切换的开销201
第12章 并发程序的测试204
12.1 正确性测试205
12.1.1 基本的单元测试206
12.1.2 对阻塞操作的测试207
12.1.3 安全性测试208
12.1.4 资源管理的测试212
12.1.5 使用回调213
12.1.6 产生更多的交替操作214
12.2 性能测试215
12.2.1 在PutTakeTest中增加计时功能215
12.2.2 多种算法的比较217
12.2.3 响应性衡量218
12.3 避免性能测试的陷阱220
12.3.1 垃圾回收220
12.3.2 动态编译220
12.3.3 对代码路径的不真实采样222
12.3.4 不真实的竞争程度222
12.3.5 无用代码的消除223
12.4 其他的测试方法224
12.4.1 代码审查224
12.4.2 静态分析工具224
12.4.3 面向方面的测试技术226
12.4.4 分析与监测工具226
第四部分 高级主题
第13章 显式锁227
13.1 Lock与 ReentrantLock227
13.1.1 轮询锁与定时锁228
13.1.2 可中断的锁获取操作230
13.1.3 非块结构的加锁231
13.2 性能考虑因素231
13.3 公平性232
13.4 在synchronized和ReentrantLock之间进行选择234
13.5 读-写锁235
第14章 构建自定义的同步工具238
14.1 状态依赖性的管理238
14.1.1 示例:将前提条件的失败传递给调用者240
14.1.2 示例:通过轮询与休眠来实现简单的阻塞241
14.1.3 条件队列243
14.2 使用条件队列244
14.2.1 条件谓词244
14.2.2 过早唤醒245
14.2.3 丢失的信号246
14.2.4 通知247
14.2.5 示例:阀门类248
14.2.6 子类的安全问题249
14.2.7 封装条件队列250
14.2.8 入口协议与出口协议250
14.3 显式的Condition对象251
14.4 Synchronizer剖析253
14.5 AbstractQueuedSynchronizer254
14.6 java.util.concurrent同步器类中的 AQS257
14.6.1 ReentrantLock257
14.6.2 Semaphore与CountDownLatch258
14.6.3 FutureTask259
14.6.4 ReentrantReadWriteLock259
第15章 原子变量与非阻塞同步机制261
15.1 锁的劣势261
15.2 硬件对并发的支持262
15.2.1 比较并交换263
15.2.2 非阻塞的计数器264
15.2.3 JVM对CAS的支持265
15.3 原子变量类265
15.3.1 原子变量是一种“更好的volatile”266
15.3.2 性能比较:锁与原子变量267
15.4 非阻塞算法270
15.4.1 非阻塞的栈270
15.4.2 非阻塞的链表272
15.4.3 原子的域更新器274
15.4.4 ABA问题275
第16章 Java内存模型277
16.1 什么是内存模型,为什么需要它277
16.1.1 平台的内存模型278
16.1.2 重排序278
16.1.3 Java内存模型简介280
16.1.4 借助同步281
16.2 发布283
16.2.1 不安全的发布283
16.2.2 安全的发布284
16.2.3 安全初始化模式284
16.2.4 双重检查加锁286
16.3 初始化过程中的安全性287


java面试宝典

简介

本书是《Java程序员面试宝典》的第4版,同时也是《程序员面试宝典》的姊妹书。
第4版在保留前三版数据结构、字符串处理、Java程序设计等主干内容的基础上,更新了部分程序员面试题目,内容主要取材于2013年至2015年多家大公司的面试题,以反映第3版图书出版后近两年来所发生的变化,目的是帮助求职者在面试过程中更好地处理一些新问题,应对新变化。
本书相对上一版的变化主要有以下三点。
1.智力测试这一章进行了分解,扩展增加一些数字类题目、图表类题目,并修正合并了一些内容,以更好地帮助求职者应对求职过程中出现的一些细节和麻烦。
2.针对程序设计这一部分,我们更新了部分例题。随着互联网相关面试题的频繁出现,我们新增并更新了如下知识点:构造函数、Java接口类型、Trie树、图的遍历、动态规划算法。采用循序渐进的办法,将重要概念加以复习,完善解题思路,而不是仅仅给出答案。
3.针对近两年面试过程中出现的新题型,本书补充了新的章节,如操作系统的线程管理问题、哈希表问题等。与第三版相比较,更加贴近市场的变化,更加与时俱进。
注:以前各个版本替换下的题目将保留在作者博客,读者可以访问以下网址获取。
http://www.cnblogs.com/programmerinterview/
就编程而言,虽然Java和C++大相径庭,但在更加有趣的语言后面的知识是设计模式、分析模式、求职解答、算法策略、信息化……也就是说,本书追求的是程序员求职背后的一些知识,即对于技术的本质理解。所以本书虽命名为“Java程序员面试宝典”,但不仅限于对Java技术的单纯讲解。因为只有这样,求职者才能不被语言所羁绊;而对于一个企业而言,除了看中求职者对语言的熟练程度,更看重工作经验、大局观和整体架构等超脱语言的知识。
本书采用一种问询式的结构。这样不仅言简意赅、平易近人,而且可以容纳更多的题目,真正达到“宝典”之效用。但本书又不仅仅作为一个题库出现,对一个类型的问题不简单加以重复。本书采用循序渐进的办法:(1)将重要概念加以复习;(2)完善解题思路,而不是仅仅给出答案;(3)给出完整可靠的答案,如果是可以验证的,要给出验证的结果;(4)综合几种解题方案,给出最优解;(5)触类旁通,给出语言背后的算法本质性解释。本书的解题思路不仅能够让读者知道什么是正确的解决方案,而且让读者明白怎样能获得最 佳方案。
本书不同于其他Java程序书籍的主要特点如下。

中国软件企业的规模比较小,面试涉及的方面比较多,且比较基础,比如常会考一些编程基础性的题,而原有的面试书籍对此方面鲜有触及。本书把国内公司面试时最易考到的基础考点,放在Java基础程序设计里面,希望能切切实实解决地实际面试问题。

面试题通过一道题考一个专类方面的能力。说起Java,人们首先想到的是Java编程语言,然而事实上,Java是一种技术,它由四个方面组成:Java编程语言、Java类文件格式、Java虚拟机和Java应用程序接口(Java API)。从面试者的角度来讲,一个测试也许能从多方面揭示应试者的素质,至少能了解应试者所掌握类的水平。市面上流行的面试书籍在此专业性的分类方面做得不够,正因为如此,本书中追求的是程序员求职背后的一些知识:对于技术的本质理解,而不仅限于对Java技术的单纯讲解。
广
本书包括但不仅仅限于Java程序员面试试题,对求职市场面试试题做了妥善分类后,将面试对象分为软件开发人员、网络工程师、测试工程师和系统管理员。实际上,市面上流行的面试书籍仅对软件开发人员比较侧重,而忽略网络工程师和测试工程师,本书就这一方面给出了详细论断,并结合大量考题分析题目特点给出应试方案。本书在这些方面做出了改进,以适应市场需求。
同时本书对外企经常考到的UML及设计模式内容也做了深入的分析,从本质上诠释面试的真谛。

第四版在保留原书主干内容的基础上,内容非常新,可以算作面试者求职前的一份全真模拟。同时作者将求职中的细节问题(简历,招聘,签约,违约),以及笔试、面试中的感悟融入书中,给求职者以最真切的人文关怀。真情实感,娓娓道来,指引读者走上理想的工作岗位。
本书不是一本万能书籍,但肯定是您工作与求职的好助手、好伙伴!
本书主要由欧立奇编著,其他参与编写的人员有朱梅、段韬、秦晓东、李启高、马雪、胥虎军、马煜、刘洋、李富星等

评价

https://book.douban.com/subject/26754536/

目录

第1部分求职过程
第1章应聘求职
1.1应聘渠道
1.2应聘流程
第2章简历书写
2.1书写简历注意事项
2.2简历模板
第3章求职五步曲
3.1笔试
3.2电话面试
3.3面试
3.4签约
3.5违约
第4章职业生涯发展规划
4.1缺乏工作经验的应届毕业生
4.2更换工作的程序员们
4.3快乐地工作
第2部分Java程序设计
第5章Java程序设计基本概念
5.1JVM
5.2i++
5.3类型转换
5.4程序结构
5.5运算符
5.6异常
5.7反射
第6章传递与引用
6.1传值与传引用
6.2静态变量与私有变量
6.3输入/输出流
6.4序列化
第7章循环、条件、概率
7.1典型递归问题
7.2循环与条件
第8章Java内存管理
8.1垃圾收集
8.2内存管理
8.3ClOne
第9章面向对象
9.1面向对象的基本概念
9.2类和对象
9.3嵌套类
9.4集合类
9.5构造函数和析构函数
9.6复制构造函数和赋值函数
9.7多态的概念
第10章继承与接口
10.1基础知识
10.2Super
10.3thiS
10.4不能继承的情况
10.5抽象类与接口
第3部分数据结构和设计模式
第11章数据结构基础
11.1堆栈
11.2链表、哈希表
11.3树、图
11.4排序基础知识
第12章字符串、数组、范型
12.1字符串基础问题
12.2StringBuffer
12.3正则表达式
12.4数字流和数组
12.5字符串其他问题
12.6范型与容器
第13章设计模式
13.1UML
13.2常见设计模式
13.3软件工程
……
第4部分操作系统、数据库、网络
第5部分Java开源
第6部分综合面试题


深入分析javaweb技术内幕

简介

《深入分析Java Web技术内幕(修订版)》新增了淘宝在无线端的应用实践,包括:CDN 动态加速、多终端化改造、 多终端Session 统一 ,以及在大流量的情况下,如何跨越性能、网络和一个地区的电力瓶颈等内容,并提供了比较完整的解决方案。
《深入分析Java Web技术内幕(修订版)》主要围绕Java Web 相关技术从三方面全面、深入地进行了阐述。首先介绍前端知识,即在JavaWeb 开发中涉及的一些基本知识,包括Web 请求过程、HTTP、DNS 技术和CDN 技术。其次深入介绍了Java 技术,包括I/O 技术、中文编码问题、Javac 编译原理、class 文件结构解析、ClassLoader 工作机制及JVM 的内存管理等。最后介绍了Java 服务端技术,主要包括Servlet、Session 与Cookie、Tomcat 与Jetty服务器、Spring 容器、iBatis 框架和Velocity 框架等原理介绍,并介绍了服务端的一些优化技术。
《深入分析Java Web技术内幕(修订版)》不仅介绍这些技术和框架的工作原理,而且结合示例来讲解,通过通俗易懂的文字和丰富、生动的配图,让读者充分并深入理解它们的内部工作原理,同时还结合了设计模式来介绍这些技术背后的架构思维。

评价

https://book.douban.com/subject/25953851/

目录

第1章 深入Web请求过程 1
1.1 B/S网络架构概述 2
1.2 如何发起一个请求 4
1.3 HTTP解析 6
1.3.1 查看HTTP信息的工具 8
1.3.2 浏览器缓存机制 9
1.4 DNS域名解析 12
1.4.1 DNS域名解析过程 12
1.4.2 跟踪域名解析过程 15
1.4.3 清除缓存的域名 18
1.4.4 几种域名解析方式 19
1.5 CDN工作机制 20
1.5.1 CDN架构 20
1.5.2 负载均衡 21
1.5.3 CDN动态加速 24
1.6 总结 25
第2章 深入分析Java I/O的工作机制 26
2.1 Java的I/O类库的基本架构 26
2.1.1 基于字节的I/O操作接口 27
2.1.2 基于字符的I/O操作接口 28
2.1.3 字节与字符的转化接口 29
2.2 磁盘I/O工作机制 30
2.2.1 几种访问文件的方式 30
2.2.2 Java访问磁盘文件 34
2.2.3 Java序列化技术 35
2.3 网络I/O工作机制 37
2.3.1 TCP状态转化 38
2.3.2 影响网络传输的因素 40
2.3.3 Java Socket的工作机制 40
2.3.4 建立通信链路 41
2.3.5 数据传输 42
2.4 NIO的工作方式 42
2.4.1 BIO带来的挑战 42
2.4.2 NIO的工作机制 43
2.4.3 Buffer的工作方式 46
2.4.4 NIO的数据访问方式 48
2.5 I/O调优 50
2.5.1 磁盘I/O优化 50
2.5.2 TCP网络参数调优 51
2.5.3 网络I/O优化 53
2.6 设计模式解析之适配器模式 57
2.6.1 适配器模式的结构 57
2.6.2 Java I/O中的适配器模式 58
2.7 设计模式解析之装饰器模式 58
2.7.1 装饰器模式的结构 59
2.7.2 Java I/O中的装饰器模式 59
2.8 适配器模式与装饰器模式的区别 60
2.9 总结 60
第3章 深入分析Java Web中的中文编码问题 61
3.1 几种常见的编码格式 61
3.1.1 为什么要编码 61
3.1.2 如何“翻译” 62
3.2 在Java中需要编码的场景 64
3.2.1 在I/O操作中存在的编码 64
3.2.2 在内存操作中的编码 66
3.3 在Java中如何编解码 67
3.3.1 按照ISO-8859-1编码 69
3.3.2 按照GB2312编码 70
3.3.3 按照GBK编码 71
3.3.4 按照UTF-16编码 71
3.3.5 按照UTF-8编码 72
3.3.6 UTF-8编码代码片段 72
3.3.7 对几种编码格式的比较 74
3.4 在Java Web中涉及的编解码 74
3.4.1 URL的编解码 76
3.4.2 HTTP Header的编解码 79
3.4.3 POST表单的编解码 79
3.4.4 HTTP BODY的编解码 80
3.5 在JS中的编码问题 81
3.5.1 外部引入JS文件 81
3.5.2 JS的URL编码 82
3.5.3 其他需要编码的地方 84
3.6 常见问题分析 84
3.6.1 中文变成了看不懂的字符 84
3.6.2 一个汉字变成一个问号 85
3.6.3 一个汉字变成两个问号 85
3.6.4 一种不正常的正确编码 86
3.7 一种繁简转换的实现方式 87
3.8 总结 88
第4章 Javac编译原理 89
4.1 Javac是什么 90
4.2 Javac编译器的基本结构 90
4.3 Javac工作原理分析 92
4.3.1 词法分析器 93
4.3.2 语法分析器 100
4.3.3 语义分析器 105
4.3.4 代码生成器 115
4.4 设计模式解析之访问者模式 118
4.4.1 访问者模式的结构 119
4.4.2 Javac中访问者模式的实现 120
4.5 总结 121
第5章 深入class文件结构 122
5.1 JVM指令集简介 122
5.1.1 与类相关的指令 124
5.1.2 方法的定义 125
5.1.3 属性的定义 126
5.1.4 其他指令集 127
5.2 class文件头的表示形式 135
5.3 常量池 139
5.3.1 UTF8常量类型 142
5.3.2 Fieldref、Methodref常量类型 143
5.3.3 Class常量类型 143
5.3.4 NameAndType常量类型 144
5.4 类信息 144
5.5 Fields和Methods定义 145
5.6 类属性描述 149
5.7 Javap生成的class文件结构 150
5.7.1 LineNumberTable 152
5.7.2 LocalVariableTable 153
5.8 总结 155
第6章 深入分析ClassLoader工作机制 156
6.1 ClassLoader类结构分析 157
6.2 ClassLoader的等级加载机制 158
6.3 如何加载class文件 161
6.3.1 加载字节码到内存 161
6.3.2 验证与解析 163
6.3.3 初始化Class对象 163
6.4 常见加载类错误分析 163
6.4.1 ClassNotFoundException 163
6.4.2 NoClassDefFoundError 164
6.4.3 UnsatisfiedLinkError 165
6.4.4 ClassCastException 166
6.4.5 ExceptionInInitializerError 167
6.5 常用的ClassLoader分析 168
6.6 如何实现自己的ClassLoader 172
6.6.1 加载自定义路径下的class文件 172
6.6.2 加载自定义格式的class文件 174
6.7 实现类的热部署 176
6.8 Java应不应该动态加载类 178
6.9 总结 179
第7章 JVM体系结构与工作方式 180
7.1 JVM体系结构 180
7.1.1 何谓JVM 180
7.1.2 JVM体系结构详解 183
7.2 JVM工作机制 185
7.2.1 机器如何执行代码 185
7.2.2 JVM为何选择基于栈的架构 186
7.2.3 执行引擎的架构设计 187
7.2.4 执行引擎的执行过程 188
7.2.5 JVM方法调用栈 193
7.3 总结 197
第8章 JVM内存管理 198
8.1 物理内存与虚拟内存 199
8.2 内核空间与用户空间 200
8.3 在Java中哪些组件需要使用内存 201
8.3.1 Java堆 201
8.3.2 线程 201
8.3.3 类和类加载器 202
8.3.4 NIO 202
8.3.5 JNI 203
8.4 JVM内存结构 203
8.4.1 PC寄存器 204
8.4.2 Java栈 204
8.4.3 堆 205
8.4.4 方法区 205
8.4.5 运行时常量池 206
8.4.6 本地方法栈 206
8.5 JVM内存分配策略 206
8.5.1 通常的内存分配策略 207
8.5.2 Java中的内存分配详解 207
8.6 JVM内存回收策略 212
8.6.1 静态内存分配和回收 212
8.6.2 动态内存分配和回收 213
8.6.3 如何检测垃圾 213
8.6.4 基于分代的垃圾收集算法 215
8.7 内存问题分析 224
8.7.1 GC日志分析 224
8.7.2 堆快照文件分析 227
8.7.3 JVM Crash日志分析 227
8.8 实例1 233
8.9 实例2 235
8.10 实例3 237
8.11 总结 242
第9章 Servlet工作原理解析 243
9.1 从Servlet容器说起 243
9.1.1 Servlet容器的启动过程 244
9.1.2 Web应用的初始化工作 247
9.2 创建Servlet实例 249
9.2.1 创建Servlet对象 250
9.2.2 初始化Servlet 250
9.3 Servlet体系结构 252
9.4 Servlet如何工作 255
9.5 Servlet中的Listener 257
9.6 Filter如何工作 259
9.7 Servlet中的url-pattern 261
9.8 总结 262
第10章 深入理解Session与Cookie 263
10.1 理解Cookie 264
10.1.1 Cookie属性项 264
10.1.2 Cookie如何工作 265
10.1.3 使用Cookie的限制 268
10.2 理解Session 269
10.2.1 Session与Cookie 269
10.2.2 Session如何工作 270
10.3 Cookie安全问题 273
10.4 分布式Session框架 274
10.4.1 存在哪些问题 274
10.4.2 可以解决哪些问题 275
10.4.3 总体实现思路 275
10.5 Cookie压缩 280
10.6 表单重复提交问题 282
10.7 多终端Session统一 283
10.8 总结 285
第11章 Tomcat的系统架构与设计模式 286
11.1 Tomcat总体设计 286
11.1.1 Tomcat总体结构 287
11.1.2 Connector组件 293
11.1.3 Servlet容器Container 298
11.1.4 Tomcat中的其他组件 309
11.2 Tomcat中的设计模式 309
11.2.1 门面设计模式 309
11.2.2 观察者设计模式 311
11.2.3 命令设计模式 313
11.2.4 责任链设计模式 314
11.3 总结 316
第12章 Jetty的工作原理解析 317
12.1 Jetty的基本架构 317
12.1.1 Jetty基本架构简介 317
12.1.2 Handler的体系结构 319
12.2 Jetty的启动过程 320
12.3 接受请求 321
12.3.1 基于HTTP工作 321
12.3.2 基于AJP工作 323
12.3.3 基于NIO方式工作 326
12.4 处理请求 327
12.5 与JBoss集成 330
12.6 与Tomcat的比较 331
12.6.1 架构比较 331
12.6.2 性能比较 332
12.6.3 特性比较 332
12.7 总结 333
第13章 Spring框架的设计理念与设计模式分析 334
13.1 Spring的骨骼架构 334
13.1.1 Spring的设计理念 335
13.1.2 核心组件如何协同工作 336
13.2 核心组件详解 337
13.2.1 Bean组件 337
13.2.2 Context组件 339
13.2.3 Core组件 340
13.2.4 Ioc容器如何工作 342
13.3 Spring中AOP的特性详解 352
13.3.1 动态代理的实现原理 352
13.3.2 Spring AOP如何实现 355
13.4 设计模式解析之代理模式 358
13.4.1 代理模式原理 358
13.4.2 Spring中代理模式的实现 358
13.5 设计模式解析之策略模式 361
13.5.1 策略模式原理 361
13.5.2 Spring中策略模式的实现 362
13.6 总结 362
第14章 Spring MVC的工作机制与设计模式 364
14.1 Spring MVC的总体设计 364
14.2 Control设计 369
14.2.1 HandlerMapping初始化 370
14.2.2 HandlerAdapter初始化 372
14.2.3 Control的调用逻辑 373
14.3 Model设计 374
14.4 View设计 375
14.5 框架设计的思考 377
14.5.1 为什么需要框架 377
14.5.2 需要什么样的框架 377
14.5.3 框架设计原则 378
14.5.4 “指航灯” 378
14.5.5 最基本的原则 378
14.6 设计模式解析之模板模式 379
14.6.1 模板模式的结构 379
14.6.2 Spring MVC中的模板模式示例 379
14.7 总结 380
第15章 深入分析iBatis框架之系统架构与映射原理 381
15.1 iBatis框架主要的类层次结构 381
15.2 iBatis框架的设计策略 382
15.3 iBatis框架的运行原理 384
15.4 示例 386
15.5 iBatis对SQL语句的解析 388
15.6 数据库字段映射到Java对象 389
15.7 示例运行的结果 391
15.8 设计模式解析之简单工厂模式 391
15.8.1 简单工厂模式的实现原理 391
15.8.2 iBatis中的简单工厂模式示例 392
15.9 设计模式解析之工厂模式 393
15.9.1 工厂模式的实现原理 393
15.9.2 iBatis中的工厂模式示例 394
15.10 总结 395
第16章 Velocity工作原理解析 397
16.1 Velocity总体架构 398
16.2 JJTree渲染过程解析 401
16.2.1 #set语法 405
16.2.2 Velocity的方法调用 406
16.2.3 #if、#elseif和#else语法 409
16.2.4 #foreach语法 410
16.2.5 #parse语法 412
16.3 事件处理机制 413
16.4 常用优化技巧 416
16.4.1 减少树的总节点数量 416
16.4.2 减少渲染耗时的节点数量 416
16.5 与JSP比较 417
16.5.1 JSP渲染机制 417
16.5.2 Velocity与JSP 423
16.6 设计模式解析之合成模式 423
16.6.1 合成模式的结构 423
16.6.2 Velocity中合成模式的实现 424
16.7 设计模式解析之解释器模式 425
16.7.1 解释器模式的结构 425
16.7.2 Velocity中解释器模式的实现 426
16.8 总结 426
第17章 Velocity优化实践 427
17.1 现实存在的问题 427
17.2 优化的理论基础 428
17.2.1 程序语言的三角形结构 428
17.2.2 数据结构减少抽象化 429
17.2.3 简单的程序复杂化 429
17.2.4 减少翻译的代价 430
17.2.5 变的转化为不变的 430
17.3 一个高效的模板引擎实现思路 430
17.3.1 vm模板如何被编译 432
17.3.2 方法调用的无反射优化 439
17.3.3 将字符输出改成字节输出 442
17.4 优化的成果 443
17.4.1 将char转成byte 443
17.4.2 无反射执行 444
17.5 其他优化手段 445
17.6 总结 445
第18章 大浏览量系统的静态化架构设计 446
18.1 淘宝大浏览量商品详情系统简介 446
18.2 系统面临哪些挑战 447
18.3 淘宝前台系统的优化历程 449
18.4 大浏览量系统的静态改造 449
18.4.1 什么是静态化系统 449
18.4.2 为什么要进行静态化架构设计 450
18.4.3 如何改造动态系统 451
18.4.4 几种静态化方案的设计及选择 453
18.4.5 如何解决失效问题 458
18.4.6 服务端静态化方案的演进:CDN化 459
18.5 总结 462


java性能优化权威指南

简介

Java性能优化圣经!Java之父重磅推荐!
本书由曾任职于Oracle/Sun的性能优化专家编写,系统而详细地讲解了性能优化的各个方面,帮助你学习Java虚拟机的基本原理、掌握一些监控Java程序性能的工具,从而快速找到程序中的性能瓶颈,并有效改善程序的运行性能。
Java性能优化的任何问题,都可以从本书中找到答案!

评价

https://book.douban.com/subject/25828043/

目录

第1章 策略、方法和方法论  1
1.1  性能问题的现状  1
1.2  性能分析的两种方法:自顶向下和自底向上  4
1.2.1  自顶向下  4
1.2.2  自底向上  5
1.3  选择正确的平台并评估系统性能  5
1.3.1  选择正确的CPU架构  6
1.3.2  评估系统性能  7
1.4  参考资料  7
第2章 操作系统性能监控  8
2.1  定义  8
2.2  CPU使用率  9
2.2.1  监控CPU使用率:Windows  9
2.2.2  监控CPU使用率:Windows typeperf  12
2.2.3  监控CPU使用率:Linux  13
2.2.4  监控CPU使用率:Solaris  14
2.2.5  命令行监控CPU使用率:Linux和Solaris  16
2.3  CPU调度程序运行队列  19
2.3.1  监控CPU调度程序运行队列:Windows  19
2.3.2  监控CPU调度程序运行队列:Solaris  21
2.3.3  监控CPU调度程序运行队列:Linux  21
2.4  内存使用率  22
2.4.1  监控内存利用率:Windows  22
2.4.2  监控内存使用率:Solaris  23
2.4.3  监控内存使用率:Linux  24
2.4.4  监控锁竞争:Solaris  25
2.4.5  监控锁竞争:Linux  26
2.4.6  监控锁竞争:Windows  27
2.4.7  隔离竞争锁  27
2.4.8  监控抢占式上下文切换  27
2.4.9  监控线程迁移  28
2.5  网络I/O使用率  28
2.5.1  监控网络I/O使用率:Solaris  29
2.5.2  监控网络I/O使用率:Linux  30
2.5.3  监控网络I/O使用率:Windows  30
2.5.4  应用性能改进的考虑  31
2.6  磁盘I/O使用率  31
2.7  其他命令行工具  34
2.8  监控CPU使用率:SPARC T系列系统  35
2.9  参考资料  36
第3章 JVM概览  38
3.1  HotSpot VM的基本架构  38
3.2  HotSpot VM运行时  40
3.2.1  命令行选项  40
3.2.2  VM生命周期  41
3.2.3  VM类加载  44
3.2.4  字节码验证  46
3.2.5  类数据共享  47
3.2.6  解释器  48
3.2.7  异常处理  49
3.2.8  同步  50
3.2.9  线程管理  51
3.2.10  C++堆管理  53
3.2.11  Java本地接口  54
3.2.12  VM致命错误处理  55
3.3  HotSpot VM垃圾收集器  56
3.3.1  分代垃圾收集  56
3.3.2  新生代  58
3.3.3  快速内存分配  60
3.3.4  垃圾收集器  60
3.3.5  Serial收集器  61
3.3.6  Parallel收集器:吞吐量为先!  62
3.3.7  Mostly-Concurrent收集器:低延迟为先!  62
3.3.8  Garbage-First收集器:CMS替代者  64
3.3.9  垃圾收集器比较  64
3.3.10  应用程序对垃圾收集器的影响  65
3.3.11  简单回顾收集器历史  65
3.4  HotSpot VM JIT编译器  65
3.4.1  类型继承关系分析  67
3.4.2  编译策略  67
3.4.3  逆优化  68
3.4.4  Client JIT编译器概览  69
3.4.5  Server JIT编译器概览  69
3.4.6  静态单赋值——程序依赖图  69
3.4.7  未来增强展望  71
3.5  HotSpot VM自适应调优  71
3.5.1  Java 1.4.2的默认值  71
3.5.2  Java 5自动优化的默认值  71
3.5.3  Java 6 Update 18更新后的默认优化值  73
3.5.4  自适应Java堆调整  74
3.5.5  超越自动优化  75
3.6  参考资料  75
第4章 JVM性能监控  77
4.1  定义  77
4.2  垃圾收集  78
4.2.1  重要的垃圾收集数据  78
4.2.2  垃圾收集报告  78
4.2.3  垃圾收集数据的离线分析  86
4.2.4  图形化工具  89
4.3  JIT编译器  103
4.4  类加载  104
4.5  Java应用监控  106
4.6  参考资料  109
第5章 Java应用性能分析  110
5.1  术语  111
5.1.1  通用性能分析术语  111
5.1.2  Oracle Solaris Studio Performance Analyzer术语  112
5.1.3  NetBeans Profiler术语  112
5.2  Oracle Solaris Studio Performance Analyzer  112
5.2.1  支持平台  113
5.2.2  下载/安装Oracle Solaris Studio Performance Analyzer  114
5.2.3  使用Oracle Solaris Studio Performance Analyzer 抓取性能数据  114
5.2.4  查看性能数据  118
5.2.5  数据表示  125
5.2.6  过滤性能数据  128
5.2.7  命令行工具er_print  129
5.3  NetBeans Profiler  135
5.3.1  支持平台  136
5.3.2  下载安装NetBeans Profiler  136
5.3.3  开始方法分析会话  137
5.3.4  Controls子面板  143
5.3.5  Status子面板  143
5.3.6  Profiling Results子面板  143
5.3.7  Saved Snapshots子面板  144
5.3.8  View子面板  144
5.3.9  Basic Telemetry子面板  144
5.3.10  查看动态结果  145
5.3.11  对结果进行快照  145
5.3.12  启动内存分析会话  146
5.3.13  查看实时结果  148
5.3.14  对结果进行快照  150
5.3.15  定位内存泄漏  150
5.3.16  分析堆转储  151
5.4  参考资料  152
第6章 Java应用性能分析技巧  153
6.1  性能优化机会  153
6.2  系统或内核态CPU使用  154
6.3  锁竞争  161
6.4  Volatile的使用  171
6.5  调整数据结构的大小  172
6.5.1  StringBuilder或StringBuffer大小的调整  172
6.5.2  Java Collection类大小调整  175
6.6  增加并行性  179
6.7  过高的CPU使用率  181
6.8  其他有用的分析提示  182
6.9  参考资料  184
第7章 JVM性能调优入门  185
7.1  方法  185
7.1.1  假设条件  187
7.1.2  测试基础设施需求  188
7.2  应用程序的系统需求  188
7.2.1  可用性  188
7.2.2  可管理性  188
7.2.3  吞吐量  189
7.2.4  延迟及响应性  189
7.2.5  内存占用  189
7.2.6  启动时间  189
7.3  对系统需求分级  190
7.4  选择JVM部署模式  190
7.4.1  单JVM部署模式  190
7.4.2  多JVM部署模式  190
7.4.3  通用建议  191
7.5  选择JVM运行模式  191
7.5.1  Client模式或Server模式  191
7.5.2  32位/64位 JVM  192
7.5.3  垃圾收集器  192
7.6  垃圾收集调优基础  193
7.6.1  性能属性  193
7.6.2  原则  193
7.6.3  命令行选项及GC日志  194
7.7  确定内存占用  197
7.7.1  约束  197
7.7.2  HotSpot VM堆的布局  197
7.7.3  堆大小调优着眼点  200
7.7.4  计算活跃数据大小  201
7.7.5  初始堆空间大小配置  202
7.7.6  其他考量因素  203
7.8  调优延迟/响应性  204
7.8.1  输入  205
7.8.2  优化新生代的大小  205
7.8.3  优化老年代的大小  207
7.8.4  为CMS调优延迟  210
7.8.5  Survivor空间介绍  212
7.8.6  解析晋升阈值  214
7.8.7  监控晋升阈值  215
7.8.8  调整Survivor空间的容量  216
7.8.9  显式的垃圾收集  222
7.8.10  并发永久代垃圾收集  223
7.8.11  调优CMS停顿时间  224
7.8.12  下一步  225
7.9  应用程序吞吐量调优  225
7.9.1  CMS吞吐量调优  225
7.9.2  Throughput收集器调优  226
7.9.3  Survivor空间调优  228
7.9.4  调优并行垃圾收集线程  231
7.9.5  在NUMA系统上部署  231
7.9.6  下一步  232
7.10  极端示例  232
7.11  其他性能命令行选项  232
7.11.1  实验性(最近最大)优化  232
7.11.2  逃逸分析  233
7.11.3  偏向锁  233
7.11.4  大页面支持  234
7.12  参考资料  236
第8章 Java应用的基准测试  237
8.1  基准测试所面临的挑战  237
8.1.1  基准测试的预热阶段  238
8.1.2  垃圾收集  240
8.1.3  使用Java Time接口  240
8.1.4  剔除无效代码  241
8.1.5  内联  247
8.1.6  逆优化  251
8.1.7  创建微基准测试的注意事项  256
8.2  实验设计  257
8.3  使用统计方法  258
8.3.1  计算均值  258
8.3.2  计算标准差  258
8.3.3  计算置信区间  259
8.3.4  使用假设测试  260
8.3.5  使用统计方法的注意事项  262
8.4  参考文献  263
8.5  参考资料  263
第9章 多层应用的基准测试  264
9.1  基准测试难题  264
9.2  企业级应用基准测试的考量  266
9.2.1  定义被测系统  266
9.2.2  制定微基准测试  266
9.2.3  定义用户交互模型  267
9.2.4  定义性能指标  270
9.2.5  扩展基准测试  273
9.2.6  用利特尔法则验证  274
9.2.7  思考时间  275
9.2.8  扩展性分析  278
9.2.9  运行基准测试  278
9.3  应用服务器监控  281
9.3.1  GlassFish监控  281
9.3.2  监控子系统  286
9.3.3  Solaris  287
9.3.4  Linux  288
9.3.5  Windows  288
9.3.6  外部系统的性能  289
9.3.7  磁盘I/O  292
9.3.8  监控和调优资源池  293
9.4  企业级应用性能分析  294
9.5  参考资料  295
第10章 Web应用的性能调优  297
10.1  Web应用的基准测试  298
10.2  Web容器的组件  298
10.2.1  HTTP连接器  299
10.2.2  Servlet引擎  300
10.3  Web容器的监控和性能调优  300
10.3.1  容器的开发和生产模式  300
10.3.2  安全管理器  301
10.3.3  JVM调优  301
10.3.4  HTTP服务和Web容器  303
10.3.5  HTTP监听器  303
10.4  最佳实践  315
10.4.1  Servlet和JSP最佳实践  315
10.4.2  内容缓存  324
10.4.3  会话持久化  328
10.4.4  HTTP服务器文件缓存  329
10.5  参考资料  333
第11章 Web Service的性能  334
11.1  XML的性能  334
11.1.1  XML处理的生命周期  335
11.1.2  解析/解编组  335
11.1.3  访问  338
11.1.4  修改  338
11.1.5  序列化/编组  339
11.2  验证  339
11.3  解析外部实体  341
11.4  XML文档的局部处理  343
11.5  选择合适的API  346
11.6  JAX-WS参考实现栈  349
11.7  Web Service基准测试  350
11.8  影响Web Service性能的因素  353
11.8.1  消息大小的影响  353
11.8.2  不同Schema类型的性能特征  355
11.8.3  终端服务器的实现  358
11.8.4  处理程序的性能  359
11.9  最佳性能实践  361
11.9.1  二进制负载的处理  361
11.9.2  处理XML文档  365
11.9.3  使用MTOM发送XML文档  365
11.9.4  使用Provider接口  368
11.9.5  快速信息集  370
11.9.6  HTTP压缩  372
11.9.7  Web Service客户端的性能  373
11.10  参考资料  374
第12章 Java持久化及Enterprise Java Bean的性能  375
12.1  EJB编程模型  376
12.2  Java持久化API及其参考实现  376
12.3  监控及调优EJB容器  379
12.3.1  线程池  380
12.3.2  Bean池和缓存  382
12.3.3  EclipseLink会话缓存  385
12.4  事务隔离级  386
12.5  Enterprise Java Bean的最佳实践  387
12.5.1  简要说明使用的EJB基准测试  387
12.5.2  EJB 2.1  388
12.5.3  EJB 3.0  400
12.6  Java持久化最佳实践  403
12.6.1  JPA查询语言中的查询  403
12.6.2  查询结果缓存  405
12.6.3  FetchType  406
12.6.4  连接池  408
12.6.5  批量更新  409
12.6.6  选择正确的数据库锁策略  411
12.6.7  不带事务的读取  411
12.6.8  继承  411
12.7  参考资料  412
附录A  重要的HotSpot VM选项  413
附录B  性能分析技巧示例源代码  429
B.1  锁竞争实现1  429
B.2  锁竞争实现2  439
B.3  锁竞争实现3  449
B.4  锁竞争实现4  459
B.5  锁竞争实现5  469
B.6  调整容量变化1  481
B.7  调整容量变化2  492
B.8  增加并发性的单线程实现  504
B.9  增加并发性的多线程实现  514


spring入门经典

简介

开发内行企业级应用的Spring实战经验
Spring入门经典一书全面透彻地介绍SpringFramework;SpringFramework是Java开发领域最流行的框架,是事实上的企业级应用开发标准。本书浓墨重彩地描述实际的企业级解决方案,每一章都提供了通俗易懂的示例和动手练习,以帮助读者快速掌握必需的技能集来运用Java的全部功能并成功开发应用程序。本书涵盖POJO模型、ORM支持、SpringMVC、REST服务、SpringSecurity等基础知识,全面指导你学习整个企业级应用程序工具集的实用功能。
主要内容
◆介绍使用SpringFramework4.0(支持Java8.0和JavaEE7)进行应用程序开发的方方面面
◆在动手实践的引导下,重点强调如何满足现实需求并提供可操作的见解
◆列举了广泛示例,可将这些示例作为具体的实验参考,并深入挖掘Java的全部功能
◆由浅入深地讲解各项技能,从而帮助开发人员熟练掌握Spring项目中常用的工具和基础概念
◆详细讨论每个企业级应用程序需要关注的横向问题,比如事务管理和安全性

评价

https://book.douban.com/subject/26652876/

目录

第1章 POJO编程模型、轻量级容器和控制反转 1
1.1 POJO编程模型 2
1.1.1 原来的EJB编程模型所存在的问题 2
1.1.2 POJO编程模型的优点 7
1.2 轻量级容器和控制反转 8
1.2.1 轻量级容器 8
1.2.2 控制反转 9
1.3 依赖注入 10
1.3.1 Setter注入 11
1.3.2 构造函数注入 11
1.3.3 Setter注入或构造函数注入 11
1.4 小结 12
1.5 习题 12
1.6 本章主要知识点 12
第2章 使用Spring进行依赖注入 15
2.1 Spring IoC容器 16
2.1.1 配置元数据 16
2.1.2 配置和使用容器 18
2.2 依赖注入 28
2.2.1 Setter注入 28
2.2.2 构造函数注入 29
2.2.3 循环依赖 32
2.2.4 依赖解析过程 33
2.2.5 重写Bean定义 34
2.2.6 使用depends-on特性 36
2.2.7 自动装配 37
2.2.8 Bean查找 41
2.3 Spring管理的Bean 42
2.3.1 命名Bean 42
2.3.2 Bean实例化方法 43
2.3.3 Bean作用域 46
2.3.4 延迟初始化 49
2.3.5 生命周期回调 50
2.3.6 Bean定义配置文件 52
2.3.7 环境 54
2.4 小结 57
2.5 习题 58
2.6 本章主要知识点 58
第3章 使用Spring MVC构建 Web应用程序 61
3.1 学习Spring MVC的功能和优点 62
3.2 使用Dispatcher Servlet机制 63
3.2.1 定义Servlet 64
3.2.2 访问Servlet上下文 65
3.3 创建第一个Spring MVC应用程序 65
3.4 使用注解配置Spring MVC 69
3.5 使用JSP处理表单 70
3.5.1 配置表单标签库 71
3.5.2 理解绑定的强大功能 72
3.5.3 使用表单 72
3.5.4 使用输入元素 73
3.5.5 输入日期 74
3.5.6 使用下拉框进行选择 74
3.5.7 使用单选按钮进行选择 75
3.5.8 使用复选框进行选择 76
3.5.9 添加标签 76
3.5.10 放置按钮 76
3.5.11 样式 76
3.6 使用注解的强大功能 81
3.6.1 @Controller 82
3.6.2 @RequestMapping 82
3.6.3 @ModeAttribute 82
3.6.4 @PathVariable 82
3.6.5 @ControllerAdvice 83
3.6.6 @InitBinder 83
3.6.7 @ExceptionHandler 83
3.7 验证用户输入 83
3.8 上传文件 88
3.9 处理异常 91
3.10 实现国际化(i18n) 92
3.11 使用主题 94
3.12 小结 97
3.13 习题 97
3.14 本章主要知识点 98
第4章 使用Spring进行JDBC数据访问 101
4.1 使用普通JDBC所带来的问题 102
4.2 引入Spring的JDBC支持 103
4.2.1 管理JDBC连接 103
4.2.2 配置和使用Spring的JDBC支持 109
4.3 使用Spring执行数据访问操作 112
4.3.1 执行查询 112
4.3.2 使用命名参数进行查询 115
4.3.3 使用In子句编写查询 116
4.3.4 在JdbcTemplate中使用PreparedStatements 117
4.3.5 插入、更新和删除记录 119
4.3.6 调用存储过程和存储函数 122
4.3.7 执行批处理操作 124
4.3.8 处理BLOB和CLOB对象 124
4.3.9 访问特定于供应商的 JDBC 方法 125
4.3.10 执行DDL操作 125
4.4 将JDBC操作模块化为Java对象 126
4.4.1 封装SQL查询执行 126
4.4.2 封装SQL DML操作 128
4.4.3 封装存储过程执行 129
4.5 异常处理和错误代码转换 130
4.5.1 常见的数据访问异常层次结构 130
4.5.2 SQLException的自动处理和转换 131
4.6 小结 131
4.7 习题 132
4.8 本章主要知识点 132
第5章 通过Spring使用JPA进行数据访问 135
5.1 概述ORM和JPA 136
5.1.1 范式不匹配 136
5.1.2 ORM框架的构建块 137
5.1.3 JPA所提供的功能 137
5.1.4 将对象模型映射到关系模型 137
5.1.5 将Java类型映射到SQL类型 142
5.1.6 配置和使用JPA 144
5.2 Spring的JPA支持 153
5.2.1 在Spring容器中设置JPA 153
5.2.2 基于纯JPA实现DAO 158
5.2.3 处理和转换异常 163
5.2.4 在Spring环境中进一步配置JPA 165
5.3 小结 168
5.4 习题 169
5.5 本章主要知识点 169
第6章 使用Spring管理事务 171
6.1 理解事务管理 172
6.2 Spring的事务抽象模型 175
6.2.1 本地事务与全局事务 177
6.2.2 PlatformTransaction Manager实现 178
6.2.3 Spring的抽象事务模型的优点 178
6.3 使用Spring进行声明式事务管理 179
6.3.1 将服务层与数据访问技术细节进行隔离 182
6.3.2 自定义默认的事务行为 184
6.3.3 在类级别使用@Transactional 185
6.3.4 理解事务传播规则 186
6.3.5 使用进行声明式事务管理 190
6.4 使用Spring进行编程式事务管理 193
6.5 在事务之前或者之后执行自定义逻辑 198
6.5.1 通知事务性操作 199
6.5.2 使用Transaction Synchronization执行事务后的逻辑 200
6.6 小结 201
6.7 习题 201
6.8 本章主要知识点 201
第7章 使用Spring进行测试驱动开发 203
7.1 配置和缓存ApplicationContext 204
7.1.1 在测试中使用基于XML和基于Java的上下文配置 204
7.1.2 使用Application ContextInitializer配置上下文 207
7.1.3 继承上下文配置 208
7.1.4 ApplicationContext缓存 210
7.2 注入测试夹具的依赖项 211
7.3 在测试中使用事务管理 213
7.4 测试Web应用程序 216
7.4.1 测试中的上下文层次结构 218
7.4.2 测试Request和Session作用域的Bean 219
7.4.3 测试Spring MVC项目 221
7.5 使用Mock对象以及其他用于测试的实用工具 225
7.5.1 Spring针对测试所提供的Mock对象 226
7.5.2 其他实用工具和测试注解 226
7.6 小结 227
7.7 习题 227
7.8 本章主要知识点 228
第8章 使用Spring进行面向方面编程 229
8.1 在Spring中开始使用AOP 230
8.2 熟悉通知的类型 235
8.2.1 Before 236
8.2.2 After Returning 236
8.2.3 After Throwing 236
8.2.4 After(Finally) 237
8.2.5 Around 238
8.3 定义切入点指示符 239
8.3.1 类型签名表达式 240
8.3.2 方法签名表达式 240
8.3.3 其他替代的切入点指示符 240
8.4 利用注解的强大功能 241
8.4.1 @Before 241
8.4.2 @PointCut 242
8.4.3 @After 243
8.4.4 @AfterReturning 243
8.4.5 @AfterThrowing 244
8.4.6 @Aspect 244
8.4.7 @Around 244
8.4.8 @DeclareParents 245
8.5 将ApectJ和Spring融合在一起 246
8.6 使用注解配置Spring AOP 250
8.7 小结 251
8.8 习题 251
8.9 本章主要知识点 252
第9章 Spring表达式语言 253
9.1 使用SpEL配置应用程序 254
9.2 创建一个分析器 256
9.3 调用方法 260
9.3.1 调用构造函数 262
9.3.2 调用静态方法 263
9.4 使用变量和函数 263
9.4.1 #root 263
9.4.2 #this 264
9.4.3 访问系统属性和环境 264
9.4.4 内联列表 264
9.4.5 注册函数 265
9.5 了解SpEL运算符 265
9.5.1 关系运算符 266
9.5.2 算术运算符 266
9.5.3 逻辑运算符 266
9.5.4 条件运算符 267
9.5.5 正则表达式运算符 268
9.5.6 安全导航运算符 269
9.5.7 集合选择和投影 269
9.5.8 选择集合中的第一个和最后一个元素 270
9.6 使用SpEL中的实用工具 271
9.6.1 访问Spring Bean 271
9.6.2 271
9.6.3 缓存中的表达式 272
9.7 小结 272
9.8 习题 272
9.9 本章主要知识点 272
第10章 缓存 275
10.1 创建第一个缓存应用程序 276
10.1.1 使用一个不同的名称配置缓存管理器 279
10.1.2 使用注解配置缓存抽象 279
10.2 使用缓存注解 280
10.2.1 @Cacheable 280
10.2.2 @CacheEvict 282
10.2.3 @CachePut 282
10.2.4 @Caching 282
10.3 实现缓存管理器 283
10.3.1 SimpleCacheManager 283
10.3.2 NoOpCacheManager 284
10.3.3 ConcurrentMap CacheManager 284
10.3.4 CompositeCache Manager 284
10.4 将SpEL投射到缓存中 285
10.5 以编程方式初始化缓存 286
10.6 寻找替换的缓存提供程序 288
10.6.1 Ehcache 288
10.6.2 Guava 292
10.6.3 Hazelcast 292
10.7 小结 293
10.8 习题 293
10.9 本章主要知识点 294
第11章 使用Spring开发REST风格的Web服务 295
11.1 创建第一个REST Web服务 296
11.2 从REST Web服务返回不同的HTTP状态码 307
11.3 学习一种基于注解的配置替换方法 308
11.4 通过XML使用REST Web服务 309
11.5 使用异常处理机制 312
11.6 对REST风格的服务进行单元测试 315
11.7 小结 318
11.8 习题 318
11.9 本章主要知识点 318
第12章 使用Spring Security保护Web应用程序的安全 321
12.1 为什么要使用Spring Security 322
12.2 Spring Security的功能 323
12.3 配置和使用Spring Security 324
12.4 理解Spring Security的基础构建基块 330
12.5 对用户进行身份验证 331
12.5.1 不成功的登录流程 331
12.5.2 成功的登录流程 332
12.5.3 匿名身份验证 333
12.5.4 自定义登录页面 334
12.5.5 注销过程 335
12.5.6 使用JDBC访问UserDetails 336
12.5.7 对密码进行加密 339
12.5.8 Remember-Me支持 339
12.5.9 用户会话管理 341
12.5.10 基本身份验证 342
12.6 授权Web请求和服务方法调用 343
12.6.1 授权Web请求 343
12.6.2 授权是如何工作的 345
12.6.3 基于表达式的授权 347
12.6.4 使用JSP安全标记 348
12.6.5 授权服务方法 349
12.7 小结 353
12.8 习题 354
12.9 本章主要知识点 354
第13章 Spring 4.0 357
13.1 跟上最新技术:Java 8和Java EE7支持 357
13.2 使用条件依赖项配置注入 362
13.3 对自动配置集合中的元素进行排序 365
13.4 重复的注解 367
13.5 引入新的注解 369
13.6 小结 370
13.7 习题 370
13.8 本章主要知识点 370


springboot实战

简介

在当今Java EE 开发中,Spring 框架是当之无愧的王者。而Spring Boot 是Spring 主推的基于“习惯优于配置”的原则,让你能够快速搭建应用的框架,从而使得Java EE 开发变得异常简单。
《JavaEE开发的颠覆者: Spring Boot实战》从Spring 基础、Spring MVC 基础讲起,从而无难度地引入Spring Boot 的学习。涵盖使用Spring Boot 进行Java EE 开发的绝大数应用场景,包含:Web 开发、数据访问、安全控制、批处理、异步消息、系统集成、开发与部署、应用监控、分布式系统开发等。
当你学完《JavaEE开发的颠覆者: Spring Boot实战》后,你将能使用Spring Boot 解决Java EE 开发中所遇到的绝大多数问题。

评价

https://book.douban.com/subject/26762595/

目录

第一部分 点睛Spring 4.x
第1 章 Spring 基础 2
1.1 Spring 概述 2
1.1.1 Spring 的简史 2
1.1.2 Spring 概述 3
1.2 Spring 项目快速搭建 5
1.2.1 Maven 简介 6
1.2.2 Maven 安装 6
1.2.3 Maven 的pom.xml 7
1.2.4 Spring 项目的搭建 9
1.3 Spring 基础配置 17
1.3.1 依赖注入 18
1.3.2 Java 配置 21
1.3.3 AOP 24
第2 章 Spring 常用配置 30
2.1 Bean 的Scope 30
2.1.1 点睛 30
2.1.2 示例 31
2.2 Spring EL 和资源调用. 33
2.2.1 点睛 33
2.2.2 示例 33
2.3 Bean 的初始化和销毁 37
2.3.1 点睛 37
2.3.2 演示 38
2.4 Profile 40
2.4.1 点睛 40
2.4.2 演示 41
2.5 事件(Application Event) 44
2.5.1 点睛 44
2.5.2 示例 44
第3 章 Spring 高级话题 48
3.1 Spring Aware 48
3.1.1 点睛 48
3.1.2 示例 49
3.2 多线程 51
3.2.1 点睛 51
3.2.2 示例 51
3.3 计划任务 54
3.3.1 点睛 54
3.3.2 示例 54
3.4 条件注解@Conditional 56
3.4.1 点睛 56
3.4.2 示例 57
3.5 组合注解与元注解 60
3.5.1 点睛 60
3.5.2 示例 60
3.6 @Enable*注解的工作原理 63
3.6.1 第一类:直接导入配置类 63
3.6.2 第二类:依据条件选择配置类 64
3.6.3 第三类:动态注册Bean 65
3.7 测试 66
3.7.1 点睛 66
3.7.2 示例 67
第二部分 点睛Spring MVC 4.x
第4 章 Spring MVC 基础 72
4.1 Spring MVC 概述 73
4.2 Spring MVC 项目快速搭建 74
4.2.1 点睛 74
4.2.2 示例 74
4.3 Spring MVC 的常用注解 82
4.3.1 点睛 82
4.3.2 示例 83
4.4 Spring MVC 基本配置 87
4.4.1 静态资源映射 88
4.4.2 拦截器配置 89
4.4.3 @ControllerAdvice 91
4.4.4 其他配置 94
4.5 Spring MVC 的高级配置 98
4.5.1 文件上传配置 98
4.5.2 自定义HttpMessageConverter 101
4.5.3 服务器端推送技术 106
4.6 Spring MVC 的测试 113
4.6.1 点睛 113
4.6.2 示例 114
第三部分 实战Spring Boot
第5 章 Spring Boot 基础 122
5.1 Spring Boot 概述 122
5.1.1 什么是Spring Boot 122
5.1.2 Spring Boot 核心功能 122
5.1.3 Spring Boot 的优缺点 124
5.1.4 关于本书的Spring Boot 版本 124
5.2 Spring Boot 快速搭建 124
5.2.1 http://start.spring.io 124
5.2.2 Spring Tool Suite 127
5.2.3 IntelliJ IDEA 129
5.2.4 Spring Boot CLI 132
5.2.5 Maven 手工构建 134
5.2.6 简单演示 136
第6 章 Spring Boot 核心 138
6.1 基本配置 138
6.1.1 入口类和@SpringBootApplication 138
6.1.2 关闭特定的自动配置 139
6.1.3 定制Banner 139
6.1.4 Spring Boot 的配置文件 140
6.1.5 starter pom 141
6.1.6 使用xml 配置 143
6.2 外部配置 143
6.2.1 命令行参数配置 143
6.2.2 常规属性配置 144
6.2.3 类型安全的配置(基于properties) 145
6.3 日志配置 148
6.4 Profile 配置 148
实战 148
6.5 Spring Boot 运行原理 150
6.5.1 运作原理 153
6.5.2 核心注解 154
6.5.3 实例分析 157
6.5.4 实战 160
第7 章 Spring Boot 的Web 开发 170
7.1 Spring Boot 的Web 开发支持 170
7.2 Thymeleaf 模板引擎 171
7.2.1 Thymeleaf 基础知识 171
7.2.2 与Spring MVC 集成 174
7.2.3 Spring Boot 的Thymeleaf 支持 175
7.2.4 实战 177
7.3 Web 相关配置 182
7.3.1 Spring Boot 提供的自动配置 182
7.3.2 接管Spring Boot 的Web 配置 185
7.3.3 注册Servlet、Filter、Listener 186
7.4 Tomcat 配置 187
7.4.1 配置Tomcat 187
7.4.2 代码配置Tomcat 188
7.4.3 替换Tomcat 190
7.4.4 SSL 配置 191
7.5 Favicon 配置 196
7.5.1 默认的Favicon 196
7.5.2 关闭Favicon 196
7.5.3 设置自己的Favicon 197
7.6 WebSocket 197
7.6.1 什么是WebSocket 197
7.6.2 Spring Boot 提供的自动配置 197
7.6.3 实战 198
7.7 基于Bootstrap 和AngularJS 的现代Web 应用 212
7.7.1 Bootstrap 213
7.7.2 AngularJS 216
7.7.3 实战 222
第8 章 Spring Boot 的数据访问 233
8.1 引入Docker 237
8.1.1 Docker 的安装 238
8.1.2 Docker 常用命令及参数 242
8.1.3 下载本书所需的Docker 镜像 247
8.1.4 异常处理 247
8.2 Spring Data JPA 248
8.2.1 点睛Spring Data JPA 248
8.2.2 Spring Boot 的支持 258
8.2.3 实战 260
8.3 Spring Data REST 284
8.3.1 点睛Spring Data REST 284
8.3.2 Spring Boot 的支持 285
8.3.3 实战 286
8.4 声名式事务 297
8.4.1 Spring 的事务机制 297
8.4.2 声名式事务 298
8.4.3 注解事务行为 299
8.4.4 类级别使用@Transactional 300
8.4.5 Spring Data JPA 的事务支持 300
8.4.6 Spring Boot 的事务支持 302
8.4.7 实战 303
8.5 数据缓存Cache 309
8.5.1 Spring 缓存支持 309
8.5.2 Spring Boot 的支持 310
8.5.3 实战 312
8.5.4 切换缓存技术 319
8.6 非关系型数据库NoSQL 320
8.6.1 MongoDB 320
8.6.2 Redis 329
第9 章 Spring Boot 企业级开发 340
9.1 安全控制Spring Security 340
9.1.1 Spring Security 快速入门 340
9.1.2 Spring Boot 的支持 347
9.1.3 实战 348
9.2 批处理Spring Batch 362
9.2.1 Spring Batch 快速入门 362
9.2.2 Spring Boot 的支持 370
9.2.3 实战 371
9.3 异步消息 385
9.3.1 企业级消息代理 386
9.3.2 Spring 的支持 386
9.3.3 Spring Boot 的支持 386
9.3.4 JMS 实战 387
9.3.5 AMQP 实战 391
9.4 系统集成Spring Integration 395
9.4.1 Spring Integration 快速入门 395
9.4.2 Message 395
9.4.3 Channel 395
9.4.4 Message EndPoint 398
9.4.5 Spring Integration Java DSL 400
9.4.6 实战 400
第10 章 Spring Boot 开发部署与测试 407
10.1 开发的热部署 407
10.1.1 模板热部署 407
10.1.2 Spring Loaded 407
10.1.3 JRebel 409
10.1.4 spring-boot-devtools 413
10.2 常规部署 413
10.2.1 jar 形式 413
10.2.2 war 形式 417
10.3 云部署——基于Docker 的部署 419
10.3.1 Dockerfile 419
10.3.2 安装Docker 421
10.3.3 项目目录及文件 421
10.3.4 编译镜像 423
10.3.5 运行 424
10.4 Spring Boot 的测试 424
10.4.1 新建Spring Boot 项目 425
10.4.2 业务代码 425
10.4.3 测试用例 427
10.4.4 执行测试 429
第11 章 应用监控 431
11.1 http 431
11.1.1 新建Spring Boot 项目 432
11.1.2 测试端点 432
11.1.3 定制端点 439
11.1.4 自定义端点 440
11.1.5 自定义HealthIndicator 444
11.2 JMX 447
11.3 SSH 449
11.3.1 新建Spring Boot 项目 449
11.3.2 运行 449
11.3.3 常用命令 451
11.3.4 定制登录用户 452
11.3.5 扩展命令 452
第12 章 分布式系统开发 456
12.1 微服务、原生云应用 456
12.2 Spring Cloud 快速入门 457
12.2.1 配置服务 457
12.2.2 服务发现 457
12.2.3 路由网关 457
12.2.4 负载均衡 457
12.2.5 断路器 458
12.3 实战 458
12.3.1 项目构建 458
12.3.2 服务发现——Discovery(Eureka Server) 459
12.3.3 配置——Config(Config Server) 461
12.3.4 服务模块——Person 服务 463
12.3.5 服务模块——Some 服务 466
12.3.6 界面模块——UI(Ribbon,Feign) 468
12.3.7 断路器监控——Monitor(DashBoard) 473
12.3.8 运行 474
12.4 基于Docker 部署 478
12.4.1 Dockerfile 编写 478
12.4.2 Docker Compose 480
12.4.3 Docker-compose.yml 编写 481
12.4.4 运行 483
附录A 485
A.1 基于JHipster 的代码生成 485
A.2 常用应用属性配置列表 488


springmvc学习指南

简介

Spring MVC是Spring框架中用于Web应用快速开发的一个模块,其中的MVC是Model-View-Controller的缩写。作为当今业界最主流的Web开发框架,Spring MVC已经成为当前最热门的开发技能,同时也广泛用于桌面开发领域。
本书重在讲述如何通过Spring MVC来开发基于Java的Web应用。全书共计12章,分别从Spring框架、模型2和MVC模式、Spring MVC介绍、控制器、数据绑定和表单标签库、传唤器和格式化、验证器、表达式语言、JSTL、国际化、上传文件、下载文件多个角度介绍了Spring MVC。除此之外,本书还配有丰富的示例以供读者练习和参考。
本书是一本Spring MVC的教程,内容细致、讲解清晰,非常适合Web开发者和想要使用Spring MVC开发基于Java的Web应用的读者阅读。

评价

https://book.douban.com/subject/26411275/

目录

第一章 Spring框架 1
1.1 XML配置文件 4
1.2 Spring控制反转容器的使用 4
1.2.3 通过构造器来创建一个bean实例 5
1.2.2 通过工厂方法来创建一个bean实例 5
1.2.3 Destroy Method的使用 6
1.2.4 向构造器传参 6
1.2.5 Setter方式依赖注入 7
1.2.3 构造器方式依赖注入 10
1.3 小结 10
第二章 模型2和MVC模式 11
2.1 模型1介绍 11
2.2 模型2介绍 11
2.3 模型2之Servlet控制器 13
2.3.1 Product类 15
2.3.2 ProductForm类 15
2.3.3 ControllerServlet类 16
2.3.4 视图 20
2.3.5 测试应用 22
2.4 解耦控制器代码 23
2.5 校验器 27
2.6 后端 32
2.7 本章小结 33
第三章 Spring MVC介绍 34
3.1 采用Spring MVC的好处 34
3.2 Spring MVC的DispatcherServlet 35
3.3 Controller接口 36
3.4 第一个Spring MVC应用 37
3.4.1 目录结构 37
3.4.2 部署描述符文件和Spring MVC配置文件 38
3.4.3 Controller 39
3.4.4 View 40
3.4.5 测试应用 42
3.5 View Resolver 43
3.6 本章小结 45
第四章 基于注解的控制器 46
4.1 Spring MVC注解类型 46
4.1.1 Controller注解类型 46
4.1.2 RequestMapping注解类型 47
4.2 编写请求处理方法 50
4.3 应用基于注解的控制器 52
4.3.1 目录结构 52
4.3.2 配置文件 52
4.3.3 Controller类 55
4.3.4 View 56
4.3.5 测试应用 57
4.4 应用@Autowired和@Service进行依赖注入 58
4.5 重定向和Flash属性 62
4.6 请求参数和路径变量 63
4.7 @ModelAttribute 66
4.8 小结 67
第五章 数据绑定和form标签库 68
5.1 数据绑定概览 68
5.2 form标签库 69
5.2.1 form标签 70
5.2.2 input标签 71
5.2.3 password标签 72
5.2.4 hidden标签 72
5.2.5 textarea标签 73
5.2.6 checkbox标签 73
5.2.7 radiobutton标签 74
5.2.8 checkboxes标签 74
5.2.9 radiobuttons标签 75
5.2.10 select标签 76
5.2.11 option标签 76
5.2.12 options标签 77
5.2.13 errors标签 77
5.3 数据绑定范例 78
5.3.1 目录结构 78
5.3.2 Domain类 78
5.3.3 Controller类 80
5.3.4 Service类 82
5.3.5 配置文件 85
5.3.6 视图 86
5.3.7 测试应用程序范例 88
5.4 小结 90
第六章 Converter和Formatter 91
6.1 converter 91
6.2 formatter 97
6.3 用registrar注册formatter 99
6.4 选择converter,还是formatter? 101
6.5 小结 101
第七章 验证器 102
7.1 验证概览 102
7.2 Spring验证器 103
7.3 ValidationUtils类 104
7.4 Spring的Validator范例 105
7.5 源文件 107
7.6 Controller类 107
7.7 测试验证器 109
7.8 JSR 303验证 110
7.9 JSR 303 Validator范例 112
7.10 小结 114
第八章 表达式语言(EL) 115
8.1 表达式语言(EL)的语法 115
8.1.1 关键字 116
8.1.2 [ ]和.运算符 116
8.1.3 取值规则 117
8.2 访问JavaBean 118
8.3 EL隐式对象 118
8.3.1 pageContext 119
8.4 使用其他EL运算符 122
8.4.1 算术运算符 122
8.3.3 关系运算符 123
8.4.2 逻辑运算符 123
8.4.3 关系运算符 123
8.4.4 empty运算符 124
8.5 如何在JSP 2.0及其更高版本中配置EL 124
8.5.1 实现免脚本的JSP页面 124
8.5.2 禁用EL计算 125
8.6 小结 126
第九章 JSTL 127
9.1 下载JSTL 127
9.2 JSTL库 127
9.3 一般行为 129
9.3.1 out标签 129
9.3.2 set标签 130
9.3.3 remove标签 132
9.4 条件行为 132
9.4.1 if标签 133
9.4.2 choose、when和otherwise标签 134
9.5 遍历行为 135
9.5.1 forEach标签 135
9.5.2 forTokens标签 143
9.6 与URL相关的行为 144
9.6.1 url标签 144
9.6.2 redirect标签 146
9.7 格式化行为 146
9.7.1 formatNumber标签 146
9.7.2 formatDate标签 149
9.7.3 timeZone标签 150
9.7.4 setTimeZone标签 152
9.7.5 parseNumber 152
9.7.6 parseDate标签 153
9.8 函数 155
9.8.1 contains函数 155
9.8.2 containsIgnoreCase函数 155
9.8.3 endsWith函数 156
9.8.4 escapeXml函数 156
9.8.5 indexOf函数 156
9.8.6 join函数 156
9.8.7 length函数 157
9.8.8 replace函数 157
9.8.9 split函数 157
9.8.10 startsWith函数 158
9.8.11 substring函数 158
9.8.12 substringAfter函数 158
9.8.13 substringBefore函数 158
9.8.14 toLowerCase函数 159
9.8.15 toUpperCase函数 159
9.8.16 trim函数 159
9.9 小结 159
第十章 国际化 160
10.1 语言区域 161
10.2 国际化Spring MVC应用程序 163
10.3 将文本元件隔离成属性文件 163
10.4 读取属性文件 165
10.5 告诉Spring MVC要使用哪个语言区域 166
10.6 使用message标签 167
10.7 范例 167
10.8 小结 173
第十一章 上传文件 174
11.1 客户端编程 174
11.2 MultipartFile接口 175
11.3 用Commons FileUpload上传文件 176
11.4 Domain类 177
11.5 控制器 178
11.6 配置文件 179
11.7 JSP页面 181
11.8 应用程序的测试 183
11.9 用Servlet 3及其更高版本上传文件 184
11.10 客户端上传 188
11.11 小结 196
第十二章 下载文件 197
12.1 文件下载概览 197
12.2 范例1:隐藏资源 198
12.3 范例2:防止交叉引用 202
12.4 小结 206
附录A Tomcat 207
附录B servlet 211
附录C JavaServer Pages 236
附录D 部署描述符 258


maven实战

简介

你是否早已厌倦了日复一日的手工构建工作?你是否对各个项目风格迥异的构建系统感到恐惧?Maven——这一Java社区事实标准的项目管理工具,能帮你从琐碎的手工劳动中解脱出来,帮你规范整个组织的构建系统。不仅如此,它还有依赖管理、自动生成项目站点等超酷的特性,已经有无数的开源项目使用它来构建项目并促进团队交流,每天都有数以万计的开发者在访问中央仓库以获取他们需要的依赖。
本书内容全面而系统,Maven的原理、使用方法和高级应用尽含其中;注重实战是本书的另一个特点,不仅在各个知识点都辅有大量的小案例,而且还有一个综合性的案例贯穿全书。如果你想使用Maven,或正在使用Maven,本书将给你绝佳的指导。
本书讨论专区:http://www.juvenxu.com/mvn-in-action/

评价

https://book.douban.com/subject/5345682/

目录

  1. Maven简介
    1.1 何为Maven
    1.2 为什么需要Maven
    1.3 Maven与极限编程
    1.4 被误解的Maven
  2. Maven安装
    2.1 在Windows上安装Maven
    2.2 在基于Unix的系统上安装Maven
    2.3 安装目录分析
    2.4 设置HTTP代理
    2.5 安装m2eclipse
    2.6 安装NetBeans Maven插件
    2.7 Maven安装最佳实践
  3. Hello World
    3.1 编写POM
    3.2 编写主代码
    3.3 编写测试代码
    3.4 打包和运行
    3.5 使用Archetype生成项目骨架
    3.6 m2eclipse简单使用
    3.7 NetBeans Maven插件简单使用
  4. 背景案例
    4.1 简单的账户注册服务
    4.2 需求阐述
    4.3 简要设计
  5. 坐标和依赖
    5.1 何为Maven坐标
    5.2 坐标详解
    5.3 account-email
    5.4 依赖的配置
    5.5 依赖范围
    5.6 传递性依赖
    5.7 依赖调解
    5.8 可选依赖
    5.9 最佳实践
  6. 仓库
    6.1 何为Maven仓库
    6.2 仓库的布局
    6.3 仓库的分类
    6.4 远程仓库的配置
    6.5 快照版本
    6.6 从仓库解析依赖的机制
    6.7 镜像
    6.8 仓库搜索服务
  7. 生命周期和插件
    7.1 何为生命周期
    7.2 生命周期详解
    7.3 插件目标
    7.4 插件绑定
    7.5 插件配置
    7.6 获取插件信息
    7.7 从命令行调用插件
    7.8 插件解析机制
  8. 聚合与继承
    8.1 account-persist
    8.2 聚合
    8.3 继承
    8.4 聚合与继承的关系
    8.5 约定优于配置
    8.6 反应堆
  9. 使用 Nexus 创建私服
    9.1 Nexus简介
    9.2 安装Nexus
    9.3 Nexus的仓库与仓库组
    9.4 Nexus的索引与构件搜索
    9.5 配置Maven从Nexus下载构件
    9.6 部署构件至Nexus
    9.7 Nexus的权限管理
    9.8 Nexus的调度任务
    9.9 其他私服软件
  10. 使用 Maven 进行测试
    10.1 account-captcha
    10.2 maven-surefire-plugin简介
    10.3 跳过测试
    10.4 动态指定要运行的测试用例
    10.5 包含与排除测试用例
    10.6 测试报告
    10.7 运行TestNG测试
    10.8 重用测试代码
  11. 使用 Hudson 进行持续集成
    11.1 持续集成的作用、过程和优势
    11.2 Hudson简介
    11.3 安装Hudson
    11.4 准备Subversion仓库
    11.5 Hudson的基本系统设置
    11.6 创建Hudson任务
    11.7 监视Hudson任务状态
    11.8 Hudson用户管理
    11.9 邮件反馈
    11.10 Hudson工作目录
  12. 构建 Web 应用
    12.1 Web项目的基本结构
    12.2 account-service
    12.3 account-web
    12.4 使用jetty-maven-plugin进行测试
    12.5 使用Cargo实现自动化部署
  13. 版本管理
    13.1 何为版本管理
    13.2 Maven的版本号定义约定
    13.3 主干、标签与分支
    13.4 自动化版本发布
    13.5 自动化创建分支
    13.6 GPG签名
  14. 灵活的构建
    14.1 Maven属性
    14.2 构建环境的差异
    14.3 资源过滤
    14.4 Maven Profile
    14.5 Web资源过滤
    14.6 在Profile中激活集成测试
  15. 生成项目站点
    15.1 最简单的站点
    15.2 丰富项目信息
    15.3 项目报告插件
    15.4 自定义站点外观
    15.5 创建自定义页面
    15.6 国际化
    15.7 部署站点
  16. m2eclipse
    16.1 m2eclipse简介
    16.2 安装m2eclipse
    16.3 新建Maven项目
    16.4 导入Maven项目
    16.5 执行mvn命令
    16.6 访问Maven仓库
    16.7 管理项目依赖
    16.8 其它实用功能
  17. 编写 Maven 插件
    17.1 编写Maven插件的一般步骤
    17.2 代码行统计Maven插件
    17.3 Mojo标注
    17.4 Mojo参数
    17.5 错误处理和日志
    17.6 测试Maven插件
  18. Archetype
    18.1 Archetype使用再叙
    18.2 编写Archetype
    18.3 Archetype Catalog

eclipse精粹

简介

在利用当今最强大的Java开发环境Eclipse时,你所需了解的东西在本书中都可以找到。本书重点介绍了如何用Eclipse提高程序员的生产力。作者在本书中介绍使用Eclipse的最佳经验,全面展示了如何把Eclipse集成到敏捷开发处理中。无论是构造企业系统,还是构造Eclipse插件或其他东西,本书都有助于你更快地编写出更好的代码。
本书主要介绍当前最流行的Java开发环境Eclipse的特性与使用精要。全书共分两部分:第一部分说明了如何定制Eclipse工作空间、项目、视图和窗口,以便获得最高的效率,此外还说明了如何利用Eclipse的快速开发、导航和调试特性,最大化程序员的生产力,最优化代码的质量。第二部分完全侧重于敏捷开发的介绍,展示了如何用Eclipse快速实现小组所有权、重构、持续测试、持续集成以及其他敏捷开发操作。
本书可供应用开发人员参考,也适合广大程序设计爱好者自学。

评价

https://book.douban.com/subject/1683909/

目录

暂无


tomcat权威指南

简介

本书是一本万能工具,其主题涵盖了Apache Tomcat这一广受欢迎的开源servlet、JSP容器和高性能的web server。《Tomcat权威指南》对管理员和web站点管理员而言,具有较强的参考价值;对在开发或产品中要使用Tomcat作为web应用程序服务器的开发者而言,这是一本有用的指南书;对Tomcat感兴趣的人而言,这是一本优秀的介绍工具。
本书是最新Tomcat版本的更新,这是第二版,提供了关于servlet容器安装、配置、维护和安全防护的完整指南。实际上,鉴于具有如此多的最新信息,这本书本质上是一本新书,而不是原书的简单翻版。通过本书,您会了解到在所有主要操作系统(Windows、Linux、OSX、S01aris和FreeBSD)上使用Tomcat的详细信息,包括关于Tomcat配置文件以及部署和运行web应用程序的交互建议的详细信息。

评价

https://book.douban.com/subject/4098318/

目录

第1章 Tomcat的开幕式
安装Tomcat
Tomcat的启动、停止及重启
自动启动
安装后的测试
Tomcat从何而来?
第2章 配置Tomcat
使用Apache Web服务器
重定向Web应用程序的目录
从8080改变端口号
Java VM配置
变换JSP编译器
管理领域、角色及用户
控制会话
访问JNDI与JDBC的资源
Servlet自动重载
定制用户目录
Tomcat应用程序示例
公共网关接口(CGI)
Tbmcat Admin webapp
第3章 在Tomcat中部署Servlet与JSP Web应用程序
Web应用程序的布局
部署解包的Web应用程序目录
部署WAR文件
热部署
使用WAR文件
Manager Web应用程序
Apache Ant自动化部署
Symbolic Links
第4章 Tomcat的性能调校
测量Web服务器的性能
外部调校
内部调校
容量规划
额外的资源
第5章 与Apache Web服务器的整合
整合的优缺点
安装Apache httpd
Apache与Tomcat的整合
Tomcat在APR连接器上提供HTTP服务
第6章 Tomcat安全防护
系统安全防护
多台服务器的安全防护模式
使用SecurityManager
授予文件权限
设置Tomcat chroot Jail
过滤黑客攻击
用SSL加强Tomcat的安全防护性能
第7章 配置
server.xml
web.xml
tomcat-users.xml
catalina.policy
catalina.properties
context.xml
第8章 调试与疑难排解
解读日志文件
猎寻错误
URL与HTTP会话
用RequestDumper Valve来调试
无法停止Tomcat的疑难排解
第9章 从源代码组建Tomcat
安装Apache Ant
获取资源
下载支持库
组建Tomcat
第10章 Tomcat集群
集群术语
HTTP请求的通信序列
分布式JAVA Servlet Container
Tomcat 6集群实现
JDBC请求分布与故障复原
其他资源
第11章 闭幕式
补充资源
社区
附录A 安装Java
附录B jbchroot.c
附录C BadlnputValve.java
附录D BadlnputFiter.java
附录E RPM包文件


headFirst设计模式

简介

《HeadFirst设计模式》(中文版)共有14章,每章都介绍了几个设计模式,完整地涵盖了四人组版本全部23个设计模式。前言先介绍这本书的用法;第1章到第11章陆续介绍的设计模式为Strategy、Observer、Decorator、Abstract Factory、Factory Method、Singleton,Command、Adapter、Facade、TemplateMethod、Iterator、Composite、State、Proxy。最后三章比较特别。第12章介绍如何将两个以上的设计模式结合起来成为新的设计模式(例如著名的MVC模式),作者称其为复合设计模式(这是作者自创的名称,并非四人组的标准名词),第13章介绍如何进一步学习设计模式,如何发觉新的设计模式等主题,至于第14章则很快地浏览尚未介绍的设计模式,包括Bridge、Builder、Chain of Responsibility、Flyweight、Interpreter、Mediator、Memento、Prototype,Visitor。第1章还介绍了四个○○基本概念(抽象、封装、继承、多态),而第1章到第9章也陆续介绍了九个○○原则(Principle)。千万不要轻视这些○○原则,因为每个设计模式背后都包含了几个○○原则的概念。很多时候,在设计时有两难的情况,这时候我们必须回归到○○原则,以方便判断取舍。可以这么说:○○原则是我们的目标,而设计模式是我们的做法。

评价

https://book.douban.com/subject/2243615/

目录

谁适合读这本书?
我们知道你的大脑在想什么
元认知
让你的大脑就范
技术审校
致谢
1 欢迎来到设计模式世界:设计模式入门
模拟鸭子应用
Joe想到继承
利用接口如何?
软件开发的不变真理
分开变化和不变部分
设计鸭子的行为
测试鸭子的代码
动态地设置行为
封装行为的大局观
“有一个”比“是一个”更好
策略模式
共享模式词汇的威力
我如何使用设计模式?
设计箱内的工具
习题解答
2 让你的对象知悉现况
气象观测站
认识观察者模式
出版者+订阅者=观罕者模式
五分钟短剧:观察主题
定义观察者模式
松耦合的威力
设计气象站
实现气象站
使用Java内建的观察者模式
java.util.Observable的黑暗面
设计箱内的工具
习题解答
……
3 装饰者模式:装饰对象
4 工厂模式:烘烤OO的精华
5 单件模式:独一无二的对象
6 命令模式:封装调用
7 适配器模式与外观模式:随遇而安
8 模板方法模式:封装算法
9 送代器与组合模式:管理良好的集合
10 状态模式:事物的状态
11 代理模式:控制对象访问
12 复合模式:模式中的模式
13 与设计模式相处:真实世界中的模式
A 附录A:剩下的模式


设计模式

简介

《设计模式》系统介绍了设计模式。全书共分27章,内容包括统一建模语言基础知识、面向对象设计原则、设计模式概述、简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式、适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式、代理模式、职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式。《设计模式》结合大量实例来学习GoF设计模式,针对每一个设计模式均提供了一或两个实例,并对每一个模式进行了详尽的讲解,每一章最后均配有一定量的习题。《设计模式》既可作为高等院校计算机相关专业本科生和研究生设计模式、软件体系结构等课程教材,也可作为各软件培训机构培训教材及全国计算机技术与软件专业技术资格(水平)考试辅导教材,还可作为软件架构师、软件工程师等开发人员的参考用书。

评价

https://book.douban.com/subject/6902815/

目录

第1章 统一建模语言基础知识
1.1 uml简介
1.2 类图
1.3 顺序图
1.4 状态图
1.5 本章小结
思考与练习
第2章 面向对象设计原则
2.1 面向对象设计原则概述
2.2 单一职责原则
2.3 开闭原则
2.4 里氏代换原则
2.5 依赖倒转原则
2.6 接口隔离原则
2.7 合成复用原则
2.8 迪米特法则
2.9 本章小结
思考与练习
第3章 设计模式概述
3.1 设计模式的诞生与发展
3.2 设计模式的定义与分类
3.3 gof设计模式简介
3.4 设计模式的优点
3.5 本章小结
思考与练习
第4章 简单工厂模式
4.1 创建型模式
4.2 简单工厂模式动机与定义
4.3 简单工厂模式结构与分析
4.4 简单工厂模式实例与解析
4.5 简单工厂模式效果与应用
4.6 简单工厂模式扩展
4.7 本章小结
思考与练习
第5章 工厂方法模式
5.1 工厂方法模式动机与定义
5.2 工厂方法模式结构与分析
5.3 工厂方法模式实例与解析
5.4 工厂方法模式效果与应用
5.5 工厂方法模式扩展
5.6 本章上结
思考与练习
第6章 抽象工厂模式
6.1 抽象工厂模式动机与定义
6.2 抽象工厂模式结构与分析
6.3 抽象工厂模式实例与解析
6.4 抽象工厂模式效果与应用
6.5 抽象工厂模式扩展
6.6 本章小结
思考与练习
第7章 建造者模式
7.1 建造者模式动机与定义
7.2 建造者模式结构与分析
7.3 建造者模式实例与解析
7.4 建造者模式效果与应用
7.5 建造者模式扩展
7.6 本章小结
思考与练习
第8章 原型模式
8.1 原型模式动机与定义
8.2 原型模式结构与分析
8.3 原型模式实例与解析
8.4 原型模式效果与应用
8.5 原型模式扩展
8.6 本章小结
思考与练习
第9章 单例模式
9.1 单例模式动机与定义
9.2 单例模式结构与分析
9.3 单例模式实例与解析
9.4 单例模式效果与应用
9.5 单例模式扩展
9.6 本章小结
思考与练习
第10章 适配器模式
10.1 结构型模式
10.2 适配器模式动机与定义
10.3 适配器模式结构与分析
10.4 适配器模式实例与解析
10.5 适配器模式效果与应用
10.6 适配器模式扩展
10.7 本章小结
思考与练习
第11章 桥接模式
11.1 桥接模式动机与定义
11.2 桥接模式结构与分析
11.3 桥接模式实例与解析
11.4 桥接模式效果与应用
11.5 桥接模式扩展
11.6 本章小结
思考与练习
第12章 组合模式
12.1 组合模式动机与定义
12.2 组合模式结构与分析
12.3 组合模式实例与解析
12.4 组合模式效果与应用
12.5 组合模式扩展
12.6 本章小结
思考与练习
第13章 装饰模式
13.1 装饰模式动机与定义
13.2 装饰模式结构与分析
13.3 装饰模式实例与解析
13.4 装饰模式效果与应用
13.5 装饰模式扩展
13.6 本章小结
思考与练习
第14章 外观模式
14.1 外观模式动机与定义
14.2 外观模式结构与分析
14.3 外观模式实例与解析
14.4 外观模式效果与应用
14.5 外观模式扩展
14.6 本章小结
思考与练习
第15章 享元模式
15.1 享元模式动机与定义
15.2 享元模式结构与分析
15.3 享元模式实例与解析
15.4 享元模式效果与应用
15.5 享元模式扩展
15.6 本章小结
思考与练习
第16章 代理模式
16.1 代理模式动机与定义
16.2 代理模式结构与分析
16.3 代理模式实例与解析
16.4 代理模式效果与应用
16.5 代理模式扩展
16.6 本章小结
思考与练习
第17章 职责链模式
17.1 行为型模式
17.2 职责链模式动机与定义
17.3 职责链模式结构与分析
17.4 职责链模式实例与解析
17.5 职责链模式效果与应用
17.6 职责链模式扩展
17.7 本章上结
思考与练习
第18章 命令模式
18.1 命令模式动机与定义
18.2 命令模式结构与分析
18.3 命令模式实例与解析
18.4 命令模式效果与应用
18.5 命令模式扩展
18.6 本章小结
思考与练习
第19章 解释器模式
19.1 解释器模式动机与定义
19.2 解释器模式结构与分析
19.3 解释器模式实例与解析
19.4 解释器模式效果与应用
19.5 解释器模式扩展
19.6 本章小结
思考与练习
第20章 迭代器模式
20.1 迭代器模式动机与定义
20.2 迭代器模式结构与分析
20.3 迭代器模式实例与解析
20.4 迭代器模式效果与应用
20.5 迭代器模式扩展
20.6 本章小结
思考与练习
第21章 中介者模式
21.1 中介者模式动机与定义
21.2 中介者模式结构与分析
21.3 中介者模式实例与解析
21.4 中介者模式效果与应用
21.5 中介者模式扩展
21.6 本章小结
思考与练习
第22章 备忘录模式
22.1 备忘录模式动机与定义
22.2 备忘录模式结构与分析
22.3 备忘录模式实例与解析
22.4 备忘录模式效果与应用
22.5 备忘录模式扩展
22.6 本章小结
思考与练习
第23章 观察者模式
23.1 观察者模式动机与定义
23.2 观察者模式结构与分析
23.3 观察者模式实例与解析
23.4 观察者模式效果与应用
23.5 观察者模式扩展
23.6 本章小结
思考与练习
第24章 状态模式
24.1 状态模式动机与定义
24.2 状态模式结构与分析
24.3 状态模式实例与解析
24.4 状态模式效果与应用
24.5 状态模式扩展
24.6 本章小结
思考与练习
第25章 策略模式
25.1 策略模式动机与定义
25.2 策略模式结构与分析
25.3 策略模式实例与解析
25.4 策略模式效果与应用
25.5 策略模式扩展
25.6 本章小结
思考与练习
第26章 模板方法模式
26.1 模板方法模式动机与定义
26.2 模板方法模式结构与分析
26.3 模板方法模式实例与解析
26.4 模板方法模式效果与应用
26.5 模板方法模式扩展
26.6 本章小结
思考与练习
第27章 访问者模式
27.1 访问者模式动机与定义
27.2 访问者模式结构与分析
27.3 访问者模式实例与解析
27.4 访问者模式效果与应用
27.5 访问者模式扩展
27.6 本章小结
思考与练习


编码

简介

本书讲述的是计算机工作原理。作者用丰富的想象和清晰的笔墨将看似繁杂的理论阐述得通俗易懂,你丝毫不会感到枯燥和生硬。更重要的是,你会因此而获得对计算机工作原理较深刻的理解。这种理解不是抽象层面上的,而是具有一定深度的。

评价

https://book.douban.com/subject/4822685/

目录

第1章 至亲密友
第2章 编码与组合
第3章 布莱叶盲文与二进制码
第4章 手电筒的剖析
第5章 绕过拐角的通信
第6章 电报机与继电器
第7章 我们的十个数字
第8章 十的替代品
第9章 二进制数
第10章 逻辑与开关
第11章 门
第12章 二进制加法器
第13章 如何实现减法
第14章 反馈与触发器
第15章 字节与十六进制
第16章 存储器组织
第17章 自动操作
第18章 从算盘到芯片
第19章 两种典型的微处理器
第20章 ASCII码和字符转换
第21章 总线
第22章 操作系统
第23章 定点数和浮点数
第24章 高级语言与低级语言
第25章 图形化革命


redis开发与运维

简介

本书全面讲解Redis基本功能及其应用,并结合线上开发与运维监控中的实际使用案例,深入分析并总结了实际开发运维中遇到的“陷阱”,以及背后的原因, 包含大规模集群开发与管理的场景、应用案例与开发技巧,为高效开发运维提供了大量实际经验和建议。本书不要求读者有任何Redis使用经验,对入门与进阶DevOps的开发者提供有价值的帮助。主要内容包括:Redis的安装配置、API、各种高效功能、客户端、持久化、复制、高可用、内存、哨兵、集群、缓存设计等,Redis高可用集群解决方案,Redis设计和使用中的问题,最后提供了一个开源工具:Redis监控运维云平台CacheCloud。

评价

https://book.douban.com/subject/26971561/

目录

第1章 初识Redis 1
1.1 盛赞Redis 1
1.2 Redis特性 2
1.3 Redis使用场景 5
1.3.1 Redis可以做什么 5
1.3.2 Redis不可以做什么 5
1.4 用好Redis的建议 6
1.5 正确安装并启动Redis 6
1.5.1 安装Redis 7
1.5.2 配置、启动、操作、关闭Redis 8
1.6 Redis重大版本 11
1.7 本章重点回顾 14
第2章 API的理解和使用 15
2.1 预备 15
2.1.1 全局命令 15
2.1.2 数据结构和内部编码 18
2.1.3 单线程架构 19
2.2 字符串 21
2.2.1 命令 22
2.2.2 内部编码 27
2.2.3 典型使用场景 28
2.3 哈希 31
2.3.1 命令 32
2.3.2 内部编码 35
2.3.3 使用场景 36
2.4 列表 38
2.4.1 命令 38
2.4.2 内部编码 43
2.4.3 使用场景 44
2.5 集合 46
2.5.1 命令 46
2.5.2 内部编码 50
2.5.3 使用场景 51
2.6 有序集合 52
2.6.1 命令 53
2.6.2 内部编码 59
2.6.3 使用场景 59
2.7 键管理 60
2.7.1 单个键管理 60
2.7.2 遍历键 67
2.7.3 数据库管理 70
2.8 本章重点回顾 73
第3章 小功能大用处 74
3.1 慢查询分析 74
3.1.1 慢查询的两个配置参数 75
3.1.2 最佳实践 77
3.2 Redis Shell 78
3.2.1 redis-cli详解 78
3.2.2 redis-server详解 82
3.2.3 redis-benchmark详解 83
3.3 Pipeline 84
3.3.1 Pipeline概念 84
3.3.2 性能测试 85
3.3.3 原生批量命令与Pipeline对比 86
3.3.4 最佳实践 87
3.4 事务与Lua 87
3.4.1 事务 87
3.4.2 Lua用法简述 90
3.4.3 Redis与Lua 92
3.4.4 案例 94
3.4.5 Redis如何管理Lua脚本 96
3.5 Bitmaps 98
3.5.1 数据结构模型 98
3.5.2 命令 98
3.5.3 Bitmaps分析 101
3.6 HyperLogLog 102
3.7 发布订阅 105
3.7.1 命令 106
3.7.2 使用场景 108
3.8 GEO 109
3.9 本章重点回顾 112
第4章 客户端 113
4.1 客户端通信协议 113
4.2 Java客户端Jedis 117
4.2.1 获取Jedis 117
4.2.2 Jedis的基本使用方法 118
4.2.3 Jedis连接池的使用方法 122
4.2.4 Redis中Pipeline的使用方法 125
4.2.5 Jedis的Lua脚本 126
4.3 Python客户端redis-py 128
4.3.1 获取redis-py 128
4.3.2 redis-py的基本使用方法 128
4.3.3 redis-py中Pipeline的使用方法 130
4.3.4 redis-py中的Lua脚本使用方法 130
4.4 客户端管理 131
4.4.1 客户端API 132
4.4.2 客户端相关配置 145
4.4.3 客户端统计片段 145
4.5 客户端常见异常 146
4.6 客户端案例分析 149
4.6.1 Redis内存陡增 149
4.6.2 客户端周期性的超时 151
4.7 本章重点回顾 153
第5章 持久化 154
5.1 RDB 154
5.1.1 触发机制 154
5.1.2 流程说明 155
5.1.3 RDB文件的处理 156
5.1.4 RDB的优缺点 156
5.2 AOF 157
5.2.1 使用AOF 157
5.2.2 命令写入 157
5.2.3 文件同步 158
5.2.4 重写机制 159
5.2.5 重启加载 161
5.2.6 文件校验 162
5.3 问题定位与优化 162
5.3.1 fork操作 162
5.3.2 子进程开销监控和优化 163
5.3.3 AOF追加阻塞 165
5.4 多实例部署 166
5.5 本章重点回顾 167
第6章 复制 168
6.1 配置 168
6.1.1 建立复制 168
6.1.2 断开复制 170
6.1.3 安全性 170
6.1.4 只读 170
6.1.5 传输延迟 171
6.2 拓扑 171
6.3 原理 172
6.3.1 复制过程 172
6.3.2 数据同步 175
6.3.3 全量复制 178
6.3.4 部分复制 181
6.3.5 心跳 183
6.3.6 异步复制 184
6.4 开发与运维中的问题 184
6.4.1 读写分离 184
6.4.2 主从配置不一致 186
6.4.3 规避全量复制 186
6.4.4 规避复制风暴 187
6.5 本章重点回顾 188
第7章 Redis的噩梦:阻塞 189
7.1 发现阻塞 189
7.2 内在原因 191
7.2.1 API或数据结构使用不合理 191
7.2.2 CPU饱和 193
7.2.3 持久化阻塞 194
7.3 外在原因 195
7.3.1 CPU竞争 195
7.3.2 内存交换 195
7.3.3 网络问题 196
7.4 本章重点回顾 199
第8章 理解内存 200
8.1 内存消耗 200
8.1.1 内存使用统计 200
8.1.2 内存消耗划分 201
8.1.3 子进程内存消耗 203
8.2 内存管理 204
8.2.1 设置内存上限 204
8.2.2 动态调整内存上限 204
8.2.3 内存回收策略 205
8.3 内存优化 209
8.3.1 redisObject对象 209
8.3.2 缩减键值对象 210
8.3.3 共享对象池 211
8.3.4 字符串优化 213
8.3.5 编码优化 216
8.3.6 控制键的数量 223
8.4 本章重点回顾 225
第9章 哨兵 226
9.1 基本概念 226
9.1.1 主从复制的问题 227
9.1.2 高可用 227
9.1.3 Redis Sentinel的高可用性 229
9.2 安装和部署 232
9.2.1 部署拓扑结构 232
9.2.2 部署Redis数据节点 233
9.2.3 部署Sentinel节点 234
9.2.4 配置优化 236
9.2.5 部署技巧 243
9.3 API 244
9.4 客户端连接 249
9.4.1 Redis Sentinel的客户端 249
9.4.2 Redis Sentinel客户端基本实现原理 249
9.4.3 Java操作Redis Sentinel 251
9.5 实现原理 254
9.5.1 三个定时监控任务 254
9.5.2 主观下线和客观下线 256
9.5.3 领导者Sentinel节点选举 258
9.5.4 故障转移 261
9.6 开发与运维中的问题 262
9.6.1 故障转移日志分析 262
9.6.2 节点运维 268
9.6.3 高可用读写分离 271
9.7 本章重点回顾 272
第10章 集群 274
10.1 数据分布 274
10.1.1 数据分布理论 274
10.1.2 Redis数据分区 277
10.1.3 集群功能限制 278
10.2 搭建集群 278
10.2.1 准备节点 278
10.2.2 节点握手 280
10.2.3 分配槽 282
10.2.4 用redis-trib.rb搭建集群 284
10.3 节点通信 287
10.3.1 通信流程 287
10.3.2 Gossip消息 287
10.3.3 节点选择 290
10.4 集群伸缩 291
10.4.1 伸缩原理 291
10.4.2 扩容集群 293
10.4.3 收缩集群 301
10.5 请求路由 305
10.5.1 请求重定向 305
10.5.2 Smart客户端 309
10.5.3 ASK重定向 318
10.6 故障转移 323
10.6.1 故障发现 323
10.6.2 故障恢复 329
10.6.3 故障转移时间 334
10.6.4 故障转移演练 334
10.7 集群运维 336
10.7.1 集群完整性 336
10.7.2 带宽消耗 337
10.7.3 Pub/Sub广播问题 337
10.7.4 集群倾斜 338
10.7.5 集群读写分离 339
10.7.6 手动故障转移 341
10.7.7 数据迁移 344
10.8 本章重点回顾 344
第11章 缓存设计 346
11.1 缓存的收益和成本 346
11.2 缓存更新策略 347
11.3 缓存粒度控制 349
11.4 穿透优化 350
11.5 无底洞优化 352
11.6 雪崩优化 359
11.7 热点key重建优化 360
11.8 本章重点回顾 364
第12章 开发运维的“陷阱” 365
12.1 Linux配置优化 365
12.1.1 内存分配控制 365
12.1.2 swappiness 367
12.1.3 THP 369
12.1.4 OOM killer 370
12.1.5 使用NTP 371
12.1.6 ulimit 371
12.1.7 TCP backlog 372
12.2 flushall/flushdb误操作 372
12.2.1 缓存与存储 373
12.2.2 借助AOF机制恢复 373
12.2.3 RDB有什么变化 374
12.2.4 从节点有什么变化 374
12.2.5 快速恢复数据 374
12.3 安全的Redis 375
12.3.1 Redis密码机制 377
12.3.2 伪装危险命令 378
12.3.3 防火墙 380
12.3.4 bind 380
12.3.5 定期备份数据 381
12.3.6 不使用默认端口 381
12.3.7 使用非root用户启动 381
12.4 处理bigkey 382
12.4.1 bigkey的危害 382
12.4.2 如何发现 382
12.4.3 如何删除 383
12.4.4 最佳实践思路 386
12.5 寻找热点key 386
12.6 本章重点回顾 391
第13章 Redis监控运维云平台CacheCloud 392
13.1 CacheCloud是什么 392
13.1.1 现有问题 393
13.1.2 CacheCloud基本功能 393
13.2 快速部署 395
13.2.1 CacheCloud环境需求 395
13.2.2 CacheCloud快速开始 395
13.3 机器部署 397
13.3.1 部署脚本 398
13.3.2 添加机器 399
13.4 接入应用 400
13.4.1 总体流程 401
13.4.2 账户申请和审批 401
13.4.3 应用申请和审批 402
13.4.4 客户端接入 405
13.5 用户功能 407
13.5.1 应用统计信息 408
13.5.2 实例列表 409
13.5.3 应用详情 409
13.5.4 命令曲线 409
13.5.5 CacheCloud Redis Shell控制台 410
13.5.6 慢查询 410
13.5.7 应用拓扑 411
13.6 运维功能 413
13.6.1 应用运维 413
13.6.2 接入已存在的Redis节点 415
13.6.3 Redis配置模板 416
13.6.4 迁移工具 417
13.6.5 监控报警 420
13.6.6 系统配置管理 422
13.7 客户端上报 423
13.7.1 客户端上报整体设计 424
13.7.2 Jedis核心代码修改 424
13.7.3 带上报功能的客户端 426
13.7.4 CacheCloud客户端统计 427
13.8 本章重点回顾 429
第14章 Redis配置统计字典 430
14.1 info系统状态说明 430
14.1.1 命令说明 430
14.1.2 详细说明 431
14.2 standalone配置说明和分析 436
14.2.1 总体配置 436
14.2.2 最大内存及策略 437
14.2.3 AOF相关配置 437
14.2.4 RDB相关配置 438
14.2.5 慢查询配置 438
14.2.6 数据结构优化配置 439
14.2.7 复制相关配置 439
14.2.8 客户端相关配置 440
14.2.9 安全相关配置 440
14.3 Sentinel配置说明和分析 440
14.4 Cluster配置说明和分析 441


mysql从入门到精通

简介

适合的往往是最实用的,就像我们要讲述的MySQL一样,它的功能不是最全面的,架构也不是最完善的,但是其体积小、速度快、总体拥有和维护成本低,尤其是它具备开放源码的优势,使其迅速成为中小型企业和网站的数据库。
本书共分为4个部分(篇)和5个附录。其中第1篇为MySQL数据库基础篇,内容包括数据库所涉及的基本概念、MySQL数据库的安装与配置等。第2篇为MySQL数据库操作和应用篇,内容包括操作数据库对象、操作表对象、操作索引对象、操作视图对象、操作触发器对象和操作数据等。第3篇为MySQL数据库管理篇,内容包括MySQL数据库的用户管理和权限管理、MySQL数据库的日志管理、MySQL数据库的性能优化等。第4篇为MySQL数据库实战案例篇,内容包括Java+MySQL案例——在线书城和PHP+MySQL案例——智能考试系统两个实战案例。附录部分(光盘中)包括了MySQL数据库操作和管理技巧,以提升读者的应用技能;同时还向读者介绍了Power Designer数据库设计软件的内容。
秉承注重理论与实际开发相结合的原则,书中的每个技术点都配备了与之相对应的实例,旨在帮助MySQL数据库初学者快速入门,同时也适合MySQL数据库管理员和想全面学习MySQL数据库技术以提升应用水平的人员使用。

评价

https://book.douban.com/subject/20260737/

目录

暂无