Fork me on GitHub

Spring中文文档

  前一段时间翻译了Jetty的一部分文档,感觉对阅读英文没有大的提高(*^-^*),毕竟Jetty的受众面还是比较小的,而且翻译过程中发现Jetty的文档写的不是很好,所以呢翻译的兴趣慢慢就不大了,只能等到以后工作中用到再去翻译了(*^__^*),不管怎样下面给出翻译的地址。

+Jetty翻译章节

    Jetty文档目录:http://www.cnblogs.com/yiwangzhibujian/p/5832294.html   

    Jetty第一部分翻译详见:http://www.cnblogs.com/yiwangzhibujian/p/5832597.html

    Jetty第四部分(四:21-22)详见:http://www.cnblogs.com/yiwangzhibujian/p/5845623.html

    Jetty第四部分(四:23)详见:http://www.cnblogs.com/yiwangzhibujian/p/5856857.html

    Jetty第四部分(四:24-27)详见:http://www.cnblogs.com/yiwangzhibujian/p/5858544.html

    Jetty第四部分(四:28-30)详见:http://www.cnblogs.com/yiwangzhibujian/p/5868489.html

  估计很多人要说我半途而废了,我也不否认,毕竟当时只是一腔热血,而且英文水平确实不咋地,但是我也不会承认,因为我觉得我还是会回来的。

  现在呢,我打算学习Spring了,可是发现Spring的的参考手册(最新或者较新版,我能找到的最新中文版应该是2.5版本)还是没有中文的,因此又想着翻译Spring︿( ̄︶ ̄)︿,希望这次我能坚持翻译完,不过话说回来,我也只是想在自己学习Spring的时候留下点痕迹。

+重要提示

    本系列打算翻译的是Spring最新版Spring 5.0.0 SHAPSHOT版本,虽然在开发中,但是基本架构已开发完,功能不会有太大的变化,所以翻译最新的版本。若以后Spring 5.0.0功能有了新的变化致使参考手册有变动,我也会关注并适时修改。一个人的时间和精力毕竟有限,翻译速度和质量不要期望太高哦(*^-^*)。

    

    文档地址:http://docs.spring.io/spring/docs/5.0.0.BUILD-SNAPSHOT/spring-framework-reference/htmlsingle/

  下面给出翻译过的Spring地址。

+Spring翻译章节

    Spring中文文档-第一部分:http://www.cnblogs.com/yiwangzhibujian/p/5893219.html

    待翻译……

  当然很多人使用Spring不会使用它的所有功能,而是有选择的使用所需要的功能,这时就需要了解Spring到底有哪些功能提供给用户使用,下面就给出Spring的所有目录让客官心里有个数。如果你需要的我还没有翻译到,那么你就有两个出路:

  1、给我发消息让我跳章节优先翻译你需要的。

  2、你去看英文文档,如果有可能你翻译一下,然后我们把翻译文章的链接交换下,所有翻译链接都会在上面统一展示,这样也方便以后别的人来看。

  下面是Spring 5.0.0 SHAPSHOT文档的中文目录(带超链接即表示已翻译): 

        2.2. 各个模块
            2.2.1. 核心容器
            2.2.2. AOP 和 设备使用
            2.2.3. 消息
            2.2.4. 数据访问/集成
            2.2.5. Web
            2.2.6. 测试
        2.3. 使用场景
            2.3.1. 依赖关系管理和命名约定
                Spring 依赖的和依赖 Spring 的
                Maven 依赖管理
                Maven 依赖清单
                Gradle 依赖管理
                Ivy 依赖管理
                Zip 文件包
            2.3.2. 日志记录
                不使用 Commons Logging
                使用 SLF4J
                使用 Log4J
II. 核心技术
    3. IoC容器
        3.1. IoC容器和beans的介绍
        3.2. 容器概述
            3.2.1. 配置属性
            3.2.2. 实例化一个容器
                编写基于xml的配置元数据
            3.2.3. 容器的使用
        3.3. Bean 概述
            3.3.1. 命名 beans
                定义bean的别名
            3.3.2. 实例化 beans
                通过构造方法实例化
                通过静态工厂方法实例化
                通过实例化工厂实例化
        3.4. 依赖性
            3.4.1. 依赖注入
                基于构造方法依赖注入
                基于set方法注入
                依赖解析过程
                依赖注入例子
            3.4.2. 依赖注入和配置细节
                准确值 (基本, 字符串, 等等)
                引用其他beans (合作者)
                内部 beans
                集合 
                Null 和 空字符串值
                p-namespace的XML快捷方式
                c-namespace的XML快捷方式
                复合属性名
            3.4.3. 使用依赖的beans
            3.4.4. 延迟初始化的beans
            3.4.5. 自动装配合作的beans
                自动装配的局限性和缺点
                自动装配排除一个beans
            3.4.6. 方法注入
                查找方法注入
                任意的方法替换
        3.5. Bean作用域
            3.5.1. singleton 作用域
            3.5.2. prototype 作用域
            3.5.3. Singleton beans 和prototype-bean 依赖性
            3.5.4. Request, session, application, 和WebSocket 作用域
                初始化web 配置
                Request 作用域
                Session 作用域
                Application 作用域
                beans作用域和依赖
            3.5.5. 自定义作用域
                创建一个自定义作用域
                使用自定义作用域
        3.6. 自定义bean的属性
            3.6.1. 生命周期回调
                初始化回调
                结束回调
                默认的初始化和销毁方法
                联合生命周期
                启动和关闭回调
                在非web应用程序中合理的关闭Spring的IoC容器
            3.6.2. ApplicationContextAware 和BeanNameAware
            3.6.3. 其它Aware 接口
        3.7. Bean定义继承
        3.8. 容器扩展方面
            3.8.1. 使用BeanPostProcessor定制bean
                例子:Hello World, BeanPostProcessor-style
                例子:The Required Annotation Bean Post Processor
            3.8.2. 通过BeanFactoryPostProcessor配置元数据
                例子: the Class name substitution PropertyPlaceholderConfigurer
                例子: the PropertyOverrideConfigurer
            3.8.3. 通过FactoryBean定制实例化逻辑
        3.9. 基于注解的容器配置
            3.9.1. @Required
            3.9.2. @Autowired
            3.9.3. 基于注释和@Primary的自动微调
            3.9.4. 基于注释和@Qualifier的自动微调
            3.9.5. 使用泛型自动装配限定符
            3.9.6. 自定义装配配置器
            3.9.7. @Resource
            3.9.8. @PostConstruct 和@PreDestroy
        3.10. 类路径扫描和组件管理
            3.10.1. @Component 和 进一步构造型注解
            3.10.2. 元注解
            3.10.3. 自动检测类和注册的bean定义
            3.10.4. 使用过滤器自定义扫描
            3.10.5. 定义bean组件内的元数据
            3.10.6. 命名自动检测到的组件
            3.10.7. 为检测到的组件提供作用域
            3.10.8. 提供限定符元数据注解
        3.11. 使用 JSR 330 标准注解
            3.11.1. 使用 @Inject 和 @Named 依赖注入
            3.11.2. @Named 和 @ManagedBean: 相当于 @Component 注解
            3.11.3. JSR-330 标准注解的局限性
        3.12. 基于java的容器配置
            3.12.1. 基本概念: @Bean 和 @Configuration
            3.12.2. 使用注解配置ApplicationContext初始化Spring容器
                简单构造方法
                使用 register(Class<?>…​) 已编程方式构造容器
                启用组件扫描通过 scan(String…​)
                通过 AnnotationConfigWebApplicationContext支持web应用程序
            3.12.3. 使用@Bean注释
                声明一个 bean
                Bean 依赖关系
                接受生命周期回调
                指定bean范围
                指定bean命名
                Bean 的别名
                Bean 的描述
            3.12.4. 使用 @Configuration 注解
                注入内部bean依赖
                查找方法注入
                基于Java配置内部bean的更多信息
            3.12.5. 编写基于java的配置
                使用 @Import 注解
                有条件地包括@Configuration类或@Bean方法
                结合Java 和 XML 配置
        3.13. 环境抽象
            3.13.1. Bean定义概要文件
                @Profile
            3.13.2. XML bean定义概要文件
                激活一个概要文件
                默认概要文件
            3.13.3. 抽象 PropertySourc
            3.13.4. @PropertySource
            3.13.5. 声明占位符
        3.14. 注册一个 LoadTimeWeaver
        3.15. ApplicationContext的额外功能
            3.15.1. 使用MessageSource国际化
            3.15.2. 标准和自定义事件
                基于注解的事件监听器
                异步的注解
                观察者注解
                通用的事件
            3.15.3. 方便对底层资源的访问
            3.15.4. 方便的ApplicationContext实例化web应用程序
            3.15.5. 作为Java EE RAR文件一样部署Spring ApplicationContext
        3.16. BeanFactory
            3.16.1. BeanFactory 或 ApplicationContext?
            3.16.2. 粘合的代码和邪恶的单例
    4. 资源
        4.1. 简介
        4.2. Resource接口
        4.3. 内置的资源实现
            4.3.1. Url资源
            4.3.2. ClassPath资源
            4.3.3. 文件系统资源
            4.3.4. ServletContext资源
            4.3.5. InputStream资源
            4.3.6. ByteArray资源
        4.4. ResourceLoader
        4.5. ResourceLoaderAware 接口
        4.6. 资源依赖关系
        4.7. 应用程序上下文和资源路径
            4.7.1. 构建应用程序上下文
                构建ClassPathXmlApplicationContext实例 - 快捷方式
            4.7.2. 构造函数应用程序上下文资源路径的通配符
                Ant-类型通配符
                Classpath*: 可移植到classpath*: 前缀
                有关通配符的其他注意事项
            4.7.3. FileSystemResource 警告
    5. 验证、数据绑定和类型转换
        5.1. 简介
        5.2. 使用Spring的验证器接口进行校验
        5.3. 解决代码错误消息
        5.4. Bean操纵和BeanWrapper
            5.4.1. 设置和获取基本和嵌套的属性
            5.4.2. 内置PropertyEditor实现
                注册额外的自定义的PropertyEditors
        5.5. Spring 类型转换
            5.5.1. SPI转换器
            5.5.2. 转换工厂
            5.5.3. 通用转换
                有条件的通用的转换器
            5.5.4. 转换服务API
            5.5.5. 配置一个ConversionService
            5.5.6. 使用ConversionService编程
        5.6. Spring字段格式
            5.6.1. 格式化器SPI
            5.6.2. 注解驱动的格式
                格式注释API
            5.6.3. FormatterRegistry SPI
            5.6.4. FormatterRegistrar SPI
            5.6.5. 配置Spring MVC的格式
        5.7. 配置一个全球性的日期和时间格式
        5.8. Spring的验证
            5.8.1.  JSR- 303 Bean Validation API的概述
            5.8.2. 配置一个Bean校验器
                注入一个验证器
                配置自定义约束
                Spring驱动的方法校验
                新增的配置属性
            5.8.3. 配置一个DataBinder
            5.8.4. Spring MVC 3 校验
    6. Spring的表达式语言 (SpEL)
        6.1. 简介
        6.2. 特征概览 
        6.3. 使用Spring表达式进行计算
            6.3.1. EvaluationContext 接口
                类型转换
            6.3.2. 解析器配置
            6.3.3. SpEL 编译
                编译器配置
                编译器的局限性
        6.4. 表达支持定义bean定义
            6.4.1. 基于XML的配置
            6.4.2. 基于注解的配置
        6.5. 语言参考
            6.5.1. 文字表达方式
            6.5.2. Properties, Arrays, Lists, Maps, Indexers
            6.5.3. 内联lists
            6.5.4. 内联Maps
            6.5.5. Array 构造
            6.5.6. 方法
            6.5.7. 操作
                关系运算符
                逻辑运算符
                数学运算符
            6.5.8. 任务 
            6.5.9. 类型
            6.5.10. 构造函数
            6.5.11. 变量
                #this 和 #root 变量
            6.5.12. 函数
            6.5.13. Bean的引用
            6.5.14. 三元操作符 (If-Then-Else)
            6.5.15. Elvis 算法
            6.5.16. 安全的导航操作符
            6.5.17. 集合选择
            6.5.18. 集合映射
            6.5.19. 表达式模板
        6.6. 类中使用的例子
    7. Spring的面向切面编程
        7.1. 简介
            7.1.1. AOP概念
            7.1.2. Spring AOP的功能和目标
            7.1.3. AOP代理
        7.2. @AspectJ 支持
            7.2.1. 提供 @AspectJ 支持
                通过Java配置提供@AspectJ的支持
                通过Xml配置提供@AspectJ的支持
            7.2.2. 声明一个方面
            7.2.3. 声明一个切入点
                支持的切入点指示符
                切面表达式
                共享切面定义
                例子
                编写好的切入点
            7.2.4. 声明的建议
                前置通知
                返回后通知
                抛出后通知
                最终(finally)后的建议
                环绕通知
                通知参数
                通知订阅
            7.2.5. 说明
            7.2.6. 切面实例化模型
            7.2.7. 例子
        7.3. 基于Schema的AOP支持
            7.3.1. 声明一个方面
            7.3.2. 声明一个切入点
            7.3.3. 声明的建议
                前置通知
                返回后通知
                抛出后通知
                最终(finally)后的建议
                环绕通知
                通知参数
                通知订阅
            7.3.4. 说明
            7.3.5. 实例化模型方面
            7.3.6. Advisors
            7.3.7. 例子
        7.4. 选择使用哪一个AOP声明风格
            7.4.1. Spring AOP 或者全部AspectJ?
            7.4.2. @AspectJ 或者 XML 配置的Spring AOP?
        7.5. 混合类型方面
        7.6. 代理机制
            7.6.1. 理解AOP代理
        7.7. 编程创建@Aspectj代理
        7.8. 在Spring应用中使用@AspectJ 
            7.8.1. 在Spring中使用AspectJ进行domain object的依赖注入 
                使用@Configurable进行单元测试
                使用多个应用程序上下文
            7.8.2. Spring中其他的AspectJ切面 
            7.8.3. 使用Spring IoC来配置AspectJ的切面 
            7.8.4. 在Spring应用中使用AspectJ加载时织入(LTW) 
                一个入门例子
                Aspects
                'META-INF/aop.xml'
                需要的jar包 (JARS)
                Spring 配置
                特定于环境的配置
        7.9. 更多资源
    8. Spring AOP APIs
        8.1. 简介 
        8.2. Spring中的切入点API 
            8.2.1. 概念 
            8.2.2. 切入点运算 
            8.2.3. AspectJ切入点表达式 
            8.2.4. 便利的切入点实现 
                静态切入点
                动态切入点
            8.2.5. 切入点的超类 
            8.2.6. 自定义切入点 
        8.3. Spring的通知API 
            8.3.1. 通知的生命周期 
            8.3.2. Spring里的通知类型 
                拦截环绕通知
                前置通知
                抛出通知
                返回后通知
                引入通知
        8.4. Spring里的Advisor API 
        8.5. 使用ProxyFactoryBean创建AOP代理 
            8.5.1. 基础 
            8.5.2. JavaBean属性 
            8.5.3. 基于JDK和CGLIB的代理 
            8.5.4. 对接口进行代理 
            8.5.5. 对类进行代理 
            8.5.6. 使用“全局”通知器 
        8.6. 简化代理定义 
        8.7. 使用ProxyFactory通过编程创建AOP代理 
        8.8. 操作被通知对象 
        8.9. 使用“自动代理(autoproxy)”功能 
            8.9.1. 自动代理bean定义 
                BeanNameAutoProxyCreator
                DefaultAdvisorAutoProxyCreator
                AbstractAdvisorAutoProxyCreator
            8.9.2. 使用元数据驱动的自动代理 
        8.10. 使用TargetSource 
            8.10.1. 热交换目标源 
            8.10.2. 池化目标源 
            8.10.3. 原型目标源 
            8.10.4. ThreadLocal目标源 
        8.11. 定义新的Advice类型 
        8.12. 更多资源 
III. 测试 
    9. Spring测试简介
    10. 单元测试 
        10.1. Mock对象 
            10.1.1. Environment
            10.1.2. JNDI
            10.1.3. Servlet API
        10.2. 单元测试支持类 
            10.2.1. 普通测试工具类
            10.2.2. Spring MVC
    11. 集成测试 
        11.1. 概览 
        11.2. 集成测试的目标
            11.2.1. 上下文管理和缓存
            11.2.2. 依赖注入的测试装置
            11.2.3. 事务管理
            11.2.4. 集成测试支持类
        11.3. JDBC测试支持 
        11.4. 常用注解 
            11.4.1. Spring测试的注释
                @BootstrapWith
                @ContextConfiguration
                @WebAppConfiguration
                @ContextHierarchy
                @ActiveProfiles
                @TestPropertySource
                @DirtiesContext
                @TestExecutionListeners
                @Commit
                @Rollback
                @BeforeTransaction
                @AfterTransaction
                @Sql
                @SqlConfig
                @SqlGroup
            11.4.2. 标准注解支持
            11.4.3. Spring JUnit 4测试注释
                @IfProfileValue
                @ProfileValueSourceConfiguration
                @Timed
                @Repeat
            11.4.4. 元注释支持测试
        11.5. Spring 测试框架
            11.5.1. 关键抽象
                TestContext类
                TestContextManager类
                TestExecutionListener类
                ContextLoaders类
            11.5.2. 引导和TestContext框架
            11.5.3. TestExecutionListener 配置
                注册定制的 TestExecutionListeners
                自动发现默认的TestExecutionListeners
                TestExecutionListeners有序化
                合并TestExecutionListeners
            11.5.4. Context 管理
                通过XML资源
                通过Groovy scripts配置Context
                通过注解类配置Context
                混合 XML, Groovy scripts, 和注解类
                通过context初始化配置Context
                Context 配置继承
                环境配置文件配置Context
                通过测试属性资源配置Context
                加载一个WebApplicationContext
                Context 缓存
                Context 继承
            11.5.5. 依赖注入的测试装置
            11.5.6. 测试请求和会话作用域的bean
            11.5.7. 事务管理
                Test-managed事务
                激活或禁止事物
                事务回滚和提交行为
                编程式事务管理
                在事物外执行代码
                配置一个事物管理
                演示的所有transaction-related注解
            11.5.8. 执行SQL脚本
                通过程序执行SQL脚本
                通过@Sql执行SQL脚本
            11.5.9. Parallel test execution
            11.5.10. TestContext 框架支持类
                Spring JUnit 4 运行
                Spring JUnit 4 规则
                JUnit 4 支持类
                TestNG 支持类
        11.6. Spring MVC 测试框架
            11.6.1. 服务端测试
                静态引入
                安装测试
                期望值
                定义的期望
                过滤注册
                容器外和端到端集成测试之间的差异
                更多服务端例子
            11.6.2. HtmlUnit 集成
                为什么要集成HtmlUnit?
                MockMvc 和 HtmlUnit
                MockMvc 和 WebDriver
                MockMvc 和 Geb
            11.6.3. 客户端 REST 测试
                静态引入
                客户端 REST 测试的例子
        11.7. 宠物诊所的例子
    12. 更多资源
IV. 数据存取
    13. 事务管理
        13.1. 介绍Spring框架事务管理
        13.2. Spring框架的事务支持模型的优点
            13.2.1. 全局事务 
            13.2.2. 本地事务 
            13.2.3. Spring框架是一致编程模型
        13.3. 了解Spring框架事务抽象
        13.4. 同步事物资源
            13.4.1. 高级的同步方法
            13.4.2. 低级的同步方法
            13.4.3. TransactionAwareDataSourceProxy
        13.5. 事务管理
            13.5.1. 了解Spring框架的声明式事务实现
            13.5.2. 声明式事务实现的例子
            13.5.3. 声明式事务回滚
            13.5.4. 配置不同的事务为不同的bean
            13.5.5. <tx:advice/> 设置
            13.5.6. 使用 @Transactional
                @Transactional 设置
                通过@Transactional进行多重事物管理
                定制注解快捷方式
            13.5.7. 事务传播
                Required模式
                RequiresNew模式
                Nested模式
            13.5.8. 通知事物操作
            13.5.9. 和AspectJ一起使用@Transactional
        13.6. 编程式事务管理
            13.6.1. 使用 TransactionTemplate
                定制transaction 设置
            13.6.2. 使用 PlatformTransactionManager
        13.7. 选择编程或声明式事务管理
        13.8. 事务绑定事件
        13.9. 特定于应用服务器的集成
            13.9.1. IBM 的 WebSphere
            13.9.2. Oracle WebLogic 服务器
        13.10. 常见问题解决
            13.10.1. 为一个特定的数据源使用错误的事务管理器
        13.11. 更多资源
    14. DAO 支持
        14.1. 简介
        14.2. 一致的异常层次结构
        14.3. 使用注解配置DAO
    15. 通过JDBC访问数据
        15.1.  介绍Spring框架JDBC
            15.1.1. 选择一个JDBC数据库访问方法
            15.1.2. 包的层次结构
        15.2. 使用JDBC核心类控制基本JDBC处理和错误处理
            15.2.1. Jdbc模板
                JdbcTemplate 类使用的例子
                JdbcTemplate 最好的使用方法
            15.2.2. NamedParameterJdbcTemplate类
            15.2.3. SQLExceptionTranslator类
            15.2.4. 执行状态
            15.2.5. 运行查询
            15.2.6. 更新基本数据
            15.2.7. 获取自动生成的键
        15.3. 控制数据库连接
            15.3.1. 数据源
            15.3.2. DataSourceUtils类
            15.3.3. SmartDataSource类
            15.3.4. AbstractDataSource类
            15.3.5. SingleConnectionDataSource类
            15.3.6. DriverManagerDataSource类
            15.3.7. TransactionAwareDataSourceProxy类
            15.3.8. DataSourceTransactionManager类
            15.3.9. NativeJdbcExtractor类
        15.4. JDBC批处理操作
            15.4.1. JdbcTemplate基本批处理操作
            15.4.2. 批处理操作的对象列表
            15.4.3. 与多个批次批处理操作
        15.5. 与SimpleJdbc简化JDBC操作类
            15.5.1. 使用SimpleJdbcInsert插入数据
            15.5.2. 使用SimpleJdbcInsert检索自动生成的键
            15.5.3. 为SimpleJdbcInsert指定列
            15.5.4. 使用SqlParameterSource提供参数值
            15.5.5. 与SimpleJdbcCall调用一个存储过程
            15.5.6. 显式地声明SimpleJdbcCall参数使用
            15.5.7. 如何定义SqlParameters
            15.5.8. 使用SimpleJdbcCall调用一个存储函数
            15.5.9. 从SimpleJdbcCall中返回 ResultSet/REF 游标
        15.6. JDBC操作建模做为Java对象
            15.6.1. SqlQuery 类
            15.6.2. MappingSqlQuery 类
            15.6.3. SqlUpdate 类
            15.6.4. StoredProcedure 类
        15.7. 常见问题与参数和数据值处理
            15.7.1. 为参数提供SQL类型信息
            15.7.2. 处理BLOB和CLOB对象
            15.7.3. 为 IN 语句传入一系列值
            15.7.4. 存储过程调用的处理复杂类型
        15.8. 嵌入式数据库的支持
            15.8.1. 为什么使用嵌入式数据库?
            15.8.2. 创建一个嵌入式数据库使用Spring XML
            15.8.3. 以编程方式创建一个嵌入式数据库
            15.8.4. 嵌入式数据库类型选择
                使用 HSQL
                使用 H2
                使用 Derby
            15.8.5. 通过嵌入式数据库测试数据访问逻辑
            15.8.6. 生成唯一的嵌入式数据库的名称
            15.8.7. 扩展嵌入式数据库的支持
        15.9. 初始化数据源
            15.9.1. 初始化数据库使用Spring XML
                基于数据库实例化其他组件
    16. 对象关系映射(ORM)数据访问
        16.1. 介绍 ORM 和 Spring
        16.2. 一般ORM集成方面的考虑
            16.2.1. 资源和事务管理
            16.2.2. 异常事物
        16.3. Hibernate
            16.3.1. 在Spring容器设置SessionFactory
            16.3.2. 基于纯Hibernate API实现DAOs
            16.3.3. 声明式事务划分
            16.3.4. 编程事务界定
            16.3.5. 事务管理策略
            16.3.6. 比较容器管理和本地定义的资源
            16.3.7. Hibernate的虚假的应用服务器的警告
        16.4. JPA
            16.4.1. 在一个Spring环境中JPA设置的三个选项
                LocalEntityManagerFactoryBean 类
                从JNDI中获得EntityManagerFactory 
                LocalContainerEntityManagerFactoryBean类
                处理多个持久性单元
            16.4.2. 基于普通的JPA实现DAOs
            16.4.3. 事务管理
            16.4.4. JpaDialect 类
    17. 通过 O/X 映射解析XML
        17.1. 简介 
            17.1.1. 每一个配置项
            17.1.2. 一致的接口
            17.1.3. 一致的异常层次结构
        17.2. Marshaller 和 Unmarshaller
            17.2.1. Marshaller类
            17.2.2. Unmarshaller类
            17.2.3. XmlMappingException类
        17.3. 使用 Marshaller 和 Unmarshaller
        17.4. 基于XML Schema配置
        17.5. JAXB 技术
            17.5.1. Jaxb2Marshaller 类
                基于XML Schema配置
        17.6. Castor 框架
            17.6.1. CastorMarshaller 类
            17.6.2. 映射
                基于XML Schema配置
        17.7. JiBX 框架
            17.7.1. JibxMarshaller 类
                基于XML Schema配置
        17.8. XStream 库
            17.8.1. XStreamMarshaller 类
V. Web方面
    18. Web MVC 框架
        18.1. Spring Web MVC 框架概述
            18.1.1. Spring Web MVC特性
            18.1.2. 可插入性的MVC实现
        18.2. DispatcherServlet 类
            18.2.1. 在WebApplicationContext中指定bean的类型
            18.2.2. 默认的DispatcherServlet 配置
            18.2.3. DispatcherServlet处理顺序
        18.3. Controllers实现
            18.3.1. 通过@Controller定义控制类
            18.3.2. 通过@RequestMapping定义映射
                @RequestMapping 变型
                @Controller 和 AOP 代理
                在Spring MVC 3.1中新的类支持@RequestMapping 方法
                URI 模板模式
                URI 模板模式和正则表达式
                Path 模板
                Path 模板比较
                Path 模板和占位符
                后缀模式匹配
                后缀模式匹配和 RFD
                矩阵变量
                指定文件类型
                可延续文件类型
                Request 参数和头部值
                HTTP HEAD 和 HTTP OPTIONS
            18.3.3. 定义@RequestMapping 处理方法
                支持方法参数类型
                支持方法返回类型
                与@RequestParam绑定,请求参数方法
                通过@RequestBody 注解定义请求体
                通过@ResponseBody 定义响应体
                通过@RestController 注解创建REST 控制
                使用 HttpEntity
                在一个方法上使用 @ModelAttribute
                在方法参数上使用@ModelAttribute
                使用@SessionAttributes存储session的值
                使用@SessionAttribute已经存在的全局session值
                使用@RequestAttribute获得请求参数
                在"application/x-www-form-urlencoded" 数据类型下工作
                使用@CookieValue 注解操作注解
                使用 @RequestHeader 注解关联请求头
                方法参数和类型转换
                定制WebDataBinder初始化
                通过@ControllerAdvice 和 @RestControllerAdvice进行通知控制
                Jackson 序列化视图支持
                Jackson JSONP 支持
            18.3.4. 异步的请求处理
                异常处理异步请求
                拦截异步请求
                HTTP 六
                HTTP 流通过Server-Sent 事件
                HTTP直接流到OutputStream
                配置异步请求处理
            18.3.5. Testing Controllers
        18.4. 处理器映射
            18.4.1. 通过HandlerInterceptor拦截请求
        18.5. 解决视图
            18.5.1. 通过ViewResolver 接口解决视图
            18.5.2. ViewResolvers链
            18.5.3. 重定向到视图
                重定向视图
                重定向:前缀
                转发:前缀
            18.5.4. ContentNegotiatingViewResolver 类
        18.6. 使用flash属性
        18.7. 构建URIs
            18.7.1. 为Controllers 和 methods构建URIs
            18.7.2. 在视图中为Controllers 和 methods构建URIs
        18.8. 使用本地化
            18.8.1. 获取时区信息
            18.8.2. AcceptHeaderLocaleResolver 类
            18.8.3. CookieLocaleResolver 类
            18.8.4. SessionLocaleResolver 类
            18.8.5. LocaleChangeInterceptor 类
        18.9. 使用主题 
            18.9.1. 简介 
            18.9.2. 如何定义主题 
            18.9.3. 主题解析器
        18.10. Spring对分段文件上传(multipart file upload)的支持 
            18.10.1. 介绍 
            18.10.2. 使用 MultipartResolver 通过Commons FileUpload
            18.10.3. 使用 MultipartResolver 通过 Servlet 3.0
            18.10.4. 在表单中处理一个文件上传
            18.10.5. 从编程处理文件上传请求
        18.11. 处理异常
            18.11.1. HandlerExceptionResolver 类
            18.11.2. @ExceptionHandler 注解
            18.11.3. 处理标准的 Spring MVC 异常
            18.11.4. 通过@ResponseStatus注释业务异常
            18.11.5. 定制默认Servlet容器的错误页面
        18.12. Web 安全
        18.13. 约定优于配置支持
            18.13.1. 控制类(C) - ControllerClassNameHandlerMapping
            18.13.2. 模型类(M) - ModelMap (ModelAndView)
            18.13.3. 试图类(V) - RequestToViewNameTranslator
        18.14. HTTP 缓存支持
            18.14.1. Cache-Control HTTP 头
            18.14.2. HTTP 缓存支持静态资源
            18.14.3. 在response中支持 Cache-Control, ETag and Last-Modified 响应头信息
            18.14.4. 对ETag的支持
        18.15. 基于代码Servlet容器初始化
        18.16. 配置Spring MVC
            18.16.1. 激活MVC Java配置或MVC XML 命名空间
            18.16.2. 定制提供的配置
            18.16.3. 转换和格式化
            18.16.4. 校验
            18.16.5. 拦截
            18.16.6. 内容协商
            18.16.7. 视图控制
            18.16.8. 视图解析器
            18.16.9. 服务资源
            18.16.10. 回到“默认”Servlet服务资源
            18.16.11. 路径匹配
            18.16.12. 消息转换
            18.16.13. 通过MVC Java配置进行高级定制
            18.16.14. 通过MVC 命名空间进行高级定制
    19. 视图技术
        19.1. 简介
        19.2. Thymeleaf
        19.3. Groovy模板标记
            19.3.1. 配置
            19.3.2. 例子
        19.4. FreeMarker
            19.4.1. 依赖
            19.4.2. Context 配置
            19.4.3. 创建模板
            19.4.4. 先进FreeMarker配置
            19.4.5. 绑定支持和表单处理
                绑定指令
                简单绑定
                表单输入生成的宏
                HTML转义和XHTML合规
        19.5. JSP & JSTL
            19.5.1. 视图解析器 
            19.5.2. 'Plain-old' JSPs 与 JSTL
            19.5.3. 帮助简化开发的额外的标签 
            19.5.4. 使用Spring 表单标签库
                配置
                form 标签
                input 标签
                checkbox 标签
                checkboxes 标签
                radiobutton 标签
                radiobuttons 标签
                password 标签
                select 标签
                option 标签
                options 标签
                textarea 标签
                hidden 标签
                errors 标签
                HTTP方法转换
                HTML5 标签
        19.6. Script 模板
            19.6.1. 依赖
            19.6.2. 创建将基于脚本的模板
        19.7. XML视图
        19.8. Tiles
            19.8.1. 需要的资源 
            19.8.2. 如何集成Tiles 
                UrlBasedViewResolver 类
                ResourceBundleViewResolver 类
                SimpleSpringPreparerFactory 和 SpringBeanPreparerFactory
        19.9. XSLT
            19.9.1. 概述
                Bean 定义
                标准MVC 控制代码
                文档转换
        19.10. 文档视图(PDF/Excel)
            19.10.1. 简介
            19.10.2. 设置和安装
                文档视图定义
                控制层代码
                Excel 视图子类
                PDF 视图子类
        19.11. Feed 视图
        19.12. JSON 关系视图
        19.13. XML 关系视图
    20. CORS 支持
        20.1. 简介
        20.2. CORS 控制方法配置
        20.3. 全局CORS 配置
            20.3.1. Java配置
            20.3.2. XML 命名空间
        20.4. 高级定制
        20.5. 基于过滤的CORS支持
    21. 集成其它Web框架 
        21.1. 简介 
        21.2. 通用配置 
        21.3. JavaServer Faces 1.2
            21.3.1. SpringBeanFacesELResolver (JSF 1.2+) 类
            21.3.2. FacesContextUtils 类
        21.4. Apache Struts 2.x
        21.5. Tapestry 5.x
        21.6. 更多资源 
    22. WebSocket 支持
        22.1. 简介
            22.1.1. WebSocket 可靠选项
            22.1.2. 消息体系结构
            22.1.3. WebSocket中子协议支持
            22.1.4. 应该使用WebSocket吗?
        22.2. WebSocket API
            22.2.1. 创建和配置一个WebSocketHandler
            22.2.2. 定制 WebSocket Handshake
            22.2.3. WebSocketHandler 装饰
            22.2.4. 部署注意事项
            22.2.5. 配置WebSocket引擎
            22.2.6. 配置允许访问的源
        22.3. SockJS 可靠选项
            22.3.1. SockJS概览
            22.3.2. 激活SockJS
            22.3.3. IE 8, 9的HTTP流: Ajax/XHR 对比 IFrame
            22.3.4. 心跳消息
            22.3.5. Servlet 3 异步请求
            22.3.6. CORS Headers for SockJS
            22.3.7. SockJS 客户端
        22.4. 基于WebSocket 的STOMP 通讯架构
            22.4.1. STOMP概述
            22.4.2. 激活基于WebSocket的STOMP 
            22.4.3. 消息流
            22.4.4. 注解信息处理
            22.4.5. 发送消息
            22.4.6. 简单的代理
            22.4.7. 全功能的代理
            22.4.8. 连接到全功能的代理
            22.4.9. 在@MessageMapping 目的地使用点作为分离器
            22.4.10. 身份认证
            22.4.11. 用户目的地
            22.4.12. 监听ApplicationContext 事件和拦截消息
            22.4.13. STOMP 客户端
            22.4.14. WebSocket 范围
            22.4.15. 配置和性能
            22.4.16. 运行时监控
            22.4.17. 测试带注解的控制器方法
    23. Web Reactive 框架
        23.1. 简介
            23.1.1. Reactive 编程
            23.1.2. Spring Web Reactive 类型
        23.2. Spring Web Reactive 概览
            23.2.1. Spring Web Reactive 模型
            23.2.2. Reactive Web 客户端
        23.3. 开始使用
            23.3.1. Spring 引导启动
            23.3.2. 手动引导
            23.3.3. 在5.0 M1的支持程度
VI. 集成
    24. 在Spring中使用Remote 和 web services
        24.1. 简介
        24.2. 公开服务使用RMI
            24.2.1. 使用RmiServiceExporter提供服务
            24.2.2. 在客户端连接服务
        24.3. 通过HTTP使用Hessian来远程调用服务
            24.3.1. 为Hsssian连接DispatcherServlet和其它
            24.3.2. 使用HessianServiceExporter暴露你的beans
            24.3.3. 在客户端连接服务
            24.3.4. 使用HTTP基本身份验证服务通过暴露Hessian 
        24.4. 使用HTTP调用器公开服务
            24.4.1. 暴露的服务对象
            24.4.2. 在客户端连接服务
        24.5. Web services
            24.5.1. 使用JAX-WS提供基于servlet的服务
            24.5.2. 使用JAX-WS提供独立的服务
            24.5.3. 通过Spring支持的JAX-WS RI提供web services服务
            24.5.4. 使用JAX-WS访问web services
        24.6. JMS
            24.6.1. 服务端配置
            24.6.2. 客户端配置
        24.7. AMQP
        24.8. 自动侦测并不实现远程接口
        24.9. 考虑当选择技术
        24.10. 在客户端访问RESTful服务
            24.10.1. RestTemplate 类
                使用URI
                处理请求和响应头
                Jackson JSON 视图支持
            24.10.2. HTTP消息转换
                StringHttpMessageConverter 类
                FormHttpMessageConverter 类
                ByteArrayHttpMessageConverter 类
                MarshallingHttpMessageConverter 类
                MappingJackson2HttpMessageConverter 类
                MappingJackson2XmlHttpMessageConverter 类
                SourceHttpMessageConverter 类
                BufferedImageHttpMessageConverter 类
            24.10.3. 异步 RestTemplate
    25. 企业JavaBeans (EJB) 集成
        25.1. 简介
        25.2. 访问 EJBs
            25.2.1. 概念
            25.2.2. 访问本地 SLSBs
            25.2.3. 访问远程 SLSBs
            25.2.4. 访问 EJB 2.x SLSBs 或者 EJB 3 SLSBs
        25.3. 使用Spring的EJB支持类
            25.3.1. EJB 3 注入拦截器
    26. JMS (Java Message Service)Java消息服务
        26.1. 简介
        26.2. 使用 Spring JMS
            26.2.1. JmsTemplate 类
            26.2.2. Connections 类
                Caching Messaging Resources
                SingleConnectionFactory 类
                CachingConnectionFactory 类
            26.2.3. 目的地管理
            26.2.4. 消息侦听器容器
                SimpleMessageListenerContainer 类
                DefaultMessageListenerContainer 类
            26.2.5. 事务管理
        26.3. 发送一个消息
            26.3.1. 使用消息转换
            26.3.2. SessionCallback 和 ProducerCallback
        26.4. 接收一个消息
            26.4.1. 同步接收
            26.4.2. 异步接收 - 消息驱动 POJOs
            26.4.3. SessionAwareMessageListener 接口
            26.4.4. MessageListenerAdapter类
            26.4.5. 在事务处理消息
        26.5. 支持JCA消息端点
        26.6. 注解驱动的端点侦听器
            26.6.1. 激活监听端点注解
            26.6.2. 编程端点注册
            26.6.3. 带注解的端点方法签名
            26.6.4. 响应管理
        26.7. JMS 命名空间支持
    27. JMX
        27.1. 简介
        27.2. 将你的bean输出到 JMX
            27.2.1. 创建一个MBeanServer
            27.2.2. 复用现有的MBeanServer
            27.2.3. 延迟初始化 MBeans
            27.2.4. 自动注册 MBeans
            27.2.5. 控制登记行为
        27.3. 控制管理接口的bean
            27.3.1. MBeanInfoAssembler 接口
            27.3.2. 使用源代码级元数据 (Java 注解)
            27.3.3. 源代码级元数据类型
            27.3.4. AutodetectCapableMBeanInfoAssembler 接口
            27.3.5. 使用Java接口定义管理接口
            27.3.6. 使用 MethodNameBasedMBeanInfoAssembler
        27.4. 为你的beans指定ObjectNames 
            27.4.1. 从属性中读取ObjectNames 
            27.4.2. 使用MetadataNamingStrategy
            27.4.3. 配置基于注解的MBean输出
        27.5. JSR-160 连接
            27.5.1. 服务端配置
            27.5.2. 客户端配置
            27.5.3. JMX over Hessian or SOAP
        27.6. 通过代理访问MBeans 
        27.7. 通知
            27.7.1. 为通知注册监听器
            27.7.2. 发布通知
        27.8. 更多资源
    28. JCA CCI
        28.1. 简介
        28.2. 配置CCI
            28.2.1. 连接配置
            28.2.2. 在Spring中配置ConnectionFactory
            28.2.3. 配置CCI 连接
            28.2.4. 使用单个的CCI 连接
        28.3. 使用Spring’的CCI 连接支持
            28.3.1. 记录转换
            28.3.2. CciTemplate类
            28.3.3. DAO 支持
            28.3.4. 自动输出生成记录
            28.3.5. Summary
            28.3.6. 直接使用CCI连接和交互
            28.3.7. CciTemplate 使用例子
        28.4. 建模CCI作为操作对象的访问
            28.4.1. MappingRecordOperation 类
            28.4.2. MappingCommAreaOperation 类
            28.4.3. 自动输出生成记录
            28.4.4. Summary
            28.4.5. MappingRecordOperation 使用例子
            28.4.6. 使用MappingCommAreaOperation 例子
        28.5. 事物
    29. Email
        29.1. 简介
        29.2. 使用
            29.2.1. 基本的MailSender 和SimpleMailMessage 用法
            29.2.2. 使用JavaMailSender 和 the MimeMessagePreparator
        29.3. 使用JavaMail MimeMessageHelper
            29.3.1. 发送附件和内联资源
                附件
                内联资源
            29.3.2. 通过模板库创建email 
    30. 任务执行和调度
        30.1. 简介
        30.2. Spring TaskExecutor 概念
            30.2.1. TaskExecutor 类型
            30.2.2. 使用 TaskExecutor
        30.3. Spring TaskScheduler 概念
            30.3.1. Trigger 接口
            30.3.2. Trigger 实现类
            30.3.3. TaskScheduler 实现类
        30.4. 注解支持调度和异步执行
            30.4.1. 激活调度的注解
            30.4.2. @Scheduled 注解
            30.4.3. @Async 注解
            30.4.4. 执行资格与@Async
            30.4.5. 执行管理与@Async
        30.5. Task 命名空间
            30.5.1. 'scheduler' 元素
            30.5.2. 'executor' 元素
            30.5.3. 'scheduled-tasks' 元素
        30.6. 使用Quartz 任务调度
            30.6.1. 使用 JobDetailFactoryBean
            30.6.2. 使用 MethodInvokingJobDetailFactoryBean
            30.6.3. 使用触发器和SchedulerFactoryBean连接工作
    31. 动态语言支持
        31.1. 简介
        31.2. 首言
        31.3. 通过动态语言定义beans
            31.3.1. 基本概念
                <lang:language/> 元素
                可复制的beans
                内联动态语言源文件
                理解构造函数注入dynamic-language-backed bean
            31.3.2. JRuby beans
            31.3.3. Groovy beans
                通过一个回调自定义Groovy对象
            31.3.4. BeanShell beans
        31.4. 脚本
            31.4.1. Scripted Spring MVC 控制
            31.4.2. Scripted 校验
        31.5. 必要的
            31.5.1. AOP - 建议脚本化的bean
            31.5.2. 作用域
        31.6. 更多资源
    32. 抽象缓存
        32.1. 简介
        32.2. 理解抽象缓存
        32.3. 基于注解定义缓存
            32.3.1. @Cacheable 注解
                默认key生成
                自定义键生成策略
                默认的缓存解决方案
                定义的缓存解决方案
                异步缓存
                条件缓存
                可用缓存通过 SpEL表达式
            32.3.2. @CachePut 注解
            32.3.3. @CacheEvict 注解
            32.3.4. @Caching 注解
            32.3.5. @CacheConfig 注解
            32.3.6. 激活缓存注解
            32.3.7. 使用定制注解
        32.4. JCache (JSR-107) 注解
            32.4.1. 功能概述
            32.4.2. 激活JSR-107 支持
        32.5. 声明基于xml的缓存
        32.6. 配置缓存仓库
            32.6.1. JDK ConcurrentMap-based 缓存
            32.6.2. Ehcache-based 缓存
            32.6.3. Caffeine 缓存
            32.6.4. GemFire-based 缓存
            32.6.5. JSR-107 缓存
            32.6.6. 处理没有缓存仓库的缓存
        32.7. 通过插件使用j2ee不同的后端缓存
        32.8. 如何使用 TTL/TTI/Eviction policy/XXX 特色?
VII. 附件
    33. Spring Framework的新功能
    34. 迁移到Spring Framework 4.x
    35. Spring 注解编程模型
    36. Spring经典实用
        36.1. 经典的 ORM 实用
            36.1.1. Hibernate
                HibernateTemplate类
                基于Spring的DAOs不使用回调
        36.2. JMS 使用
            36.2.1. JmsTemplate类
            36.2.2. 异步消息接收
            36.2.3. 连接
            36.2.4. 事务管理
    37. 经典Spring AOP 使用
        37.1. Spring切面API
            37.1.1. 概念
            37.1.2. 操作切入点
            37.1.3. AspectJ切入点表达式
            37.1.4. 方便的切入点实现
                静态切入点
                动态切入点
            37.1.5. 切入点超类
            37.1.6. 自定义切入点
        37.2. Spring的通知API
            37.2.1. Advice 生活周期
            37.2.2. Spring中的Advice 类型
                拦截环绕通知
                前置通知
                抛出后通知
                返回后通知
                通知介绍
        37.3. Spring的Advisor API 
        37.4. 使用 ProxyFactoryBean 创建AOP 代理
            37.4.1. 基础
            37.4.2. JavaBean 属性
            37.4.3. JDK- 和 基于CGLIB 的代理
            37.4.4. 代理接口
            37.4.5. 代理类
            37.4.6. 使用 'global' advisors
        37.5. 简洁的代理的定义
        37.6. 以编程方式通过ProxyFactory 创建与AOP代理
        37.7. 操纵建议对象
        37.8. 使用 "autoproxy" 插件
            37.8.1. Autoproxy bean 定义
                BeanNameAutoProxyCreator类
                DefaultAdvisorAutoProxyCreator类
                AbstractAdvisorAutoProxyCreator 类
            37.8.2. 使用元数据驱动auto-proxying
        37.9. 使用 TargetSources
            37.9.1. 热可切换目标的来源
            37.9.2. Pooling 目标来源
            37.9.3. Prototype 目标来源
            37.9.4. ThreadLocal 目标来源
        37.10. 定义新的Advice 类型
        37.11. 更多资源
    38. 基于XML Schema的配置
        38.1. 简介
        38.2. 基于XML Schema的配置
            38.2.1. 引用schemas
            38.2.2. util schema属性
                <util:constant/>
                <util:property-path/>
                <util:properties/>
                <util:list/>
                <util:map/>
                <util:set/>
            38.2.3. jee schema属性
                <jee:jndi-lookup/> (简单的)
                <jee:jndi-lookup/> (通过JNDI环境设置)
                <jee:jndi-lookup/> (通过多重JNDI环境设置)
                <jee:jndi-lookup/> (复杂)
                <jee:local-slsb/> (简单的)
                <jee:local-slsb/> (复杂的)
                <jee:remote-slsb/>
            38.2.4. lang schema
            38.2.5. jms schema
            38.2.6. tx (transaction) schema
            38.2.7. aop schema
            38.2.8. context schema
                <property-placeholder/>
                <annotation-config/>
                <component-scan/>
                <load-time-weaver/>
                <spring-configured/>
                <mbean-export/>
            38.2.9. tool schema
            38.2.10. jdbc schema
            38.2.11. cache schema
            38.2.12. beans schema
    39. 可扩展的XML编写
        39.1. 简介
        39.2. 编写schema
        39.3. 写一个NamespaceHandler代码
        39.4. BeanDefinitionParser类
        39.5. 注册 handler 和 schema
            39.5.1. 'META-INF/spring.handlers'
            39.5.2. 'META-INF/spring.schemas'
        39.6. 在Spring XML配置中使用一个自定义的扩展
        39.7. 很多例子
            39.7.1. 在自定义标记嵌套自定义标记
            39.7.2. 定义属性在 'normal' 元素上
        39.8. Further Resources
    40. SpringJSP标签库
        40.1. 简介
        40.2. argument 标签
        40.3. bind 标签
        40.4. escapeBody 标签
        40.5. eval 标签
        40.6. hasBindErrors 标签
        40.7. htmlEscape 标签
        40.8. message 标签
        40.9.  nestedPath 标签
        40.10. param 标签
        40.11. theme 标签
        40.12. transform 标签
        40.13. url 标签
    41. Spring表单JSP标签库
        41.1. 简介
        41.2. button 标签
        41.3. checkbox 标签
        41.4. checkboxes 标签
        41.5. errors 标签
        41.6. form 标签
        41.7. hidden 标签
        41.8. input 标签
        41.9. label 标签
        41.10. option 标签
        41.11. options 标签
        41.12. password 标签
        41.13. radiobutton 标签
        41.14. radiobuttons 标签
        41.15. select 标签
        41.16. textarea 标签

   看完目录我觉得有点崩溃了,好长呢,这不是一个人短时间能完成的工作,本着开源共享的精神我觉得不能总想着一个人做完所有的事,我大致看过曾经翻译的Spring2.5版本,我发现有一些章节还是很相似的,甚至有些完全一模一样。所以我觉得应该对前人的翻译予以肯定,因此曾经有的我会直接拿过来,拿来的我会予以明确标识,若有变动的章节,变动部分较小的也予以标识,现予以以下声明(我会尽量联系到当初翻译的那些人征求他们的意见,相信他们会同意的,同样这些翻译也允许转载,但要保留翻译署名):

+声明

    本文档部分转载Spring 2.5开发手册,转载部分将进行简单排版并标注,Spring 2.5开发手册文档翻译人员如下:

  还有最最重要的一点,我是因为找不到最新4.X的翻译版本才有此想法的,如果大家发现已有中文翻译一定告知我,翻译还是好辛苦的(⊙︿⊙)

posted @ 2016-09-22 14:30  已往之不谏  阅读(69659)  评论(18编辑  收藏