Spring和MyBatis的外文翻译分析

合集下载

Spring和MyBatis的外文翻译..

本科生毕业设计 (论文)外文翻译原文标题MVC Design Pattern for the multi frameworkdistributed applications using XML, spring and strutsframework译文标题使用XML,Spring和struts以MVC为设计模式的多分布式应用程序框架作者所在系别计算机与遥感信息技术学院作者所在班级B12511作者姓名王硕作者学号20124051117指导教师姓名耿炎指导教师职称院长完成时间2015 年1 月北华航天工业学院教务处制译文标题使用XML,Spring和struts以MVC为设计模式的多分布式应用程序框架原文标题MVC Design Pattern for the multi frameworkdistributed applications using XML, spring and struts framework作者Praveen Gupta 译名普利文·古塔国籍印度原文出处International Journal on Computer Science and Engineering 使用XML,Spring和struts以MVC为设计模式的多分布式应用程序框架摘要：模型-视图-控制器(MVC)是一个基本的设计模式，用来分离用户界面与业务的逻辑。

近些年来，应用程序的规模越来越大，而MVC设计模式可以弱耦合不同应用层的程序。

本文提出了一种基于J2EE平台上的网络,它扩展了MVC、XML 的应用程序框架，易于维护。

这是一个包括表示层、业务层、数据持久层和数据库层的多系统层，由于其代码的具有独立性，可维护性和可重用性大大提升。

在本文中,我们使用MVC实现spring和struts框架。

我们的研究显示，应用多个框架设计应用程序时，使用MVC概念能使应用程序转变为更容易、较单一的框架。

关键字：MVC，Spring，XML一介绍近些年来，web是非常复杂的问题。

Spring和Mybatis整合英文文档翻译

Spring和Mybatis整合英文文档翻译Introduction to MyBatis-SpringMyBatis-Spring介绍MyBatis-Spring helps you integrate your MyBatis code seamlessly with Spring. Using the classes in this library, Spring will load the necessary MyBatis factory and session classes for you. This library also provides an easy way to inject MyBatis data mappers into your service beans. Finally, MyBatis-Spring will handle transactions and translate MyBatis exceptions into Spring DataAccessExceptions.MyBatis-Spring帮助我们将MyBatis代码无缝的和Spring整合起来。

通过使用这个类库中类，Spring将为我们加载MyBatis工厂以及session相关的类。

这个类库也提供了一种简单的方式注入MyBatis 数据映射器到我们的业务Beans中去。

最后，MyBatis-Spring将会处理事务以及转换MyBatis的异常为Spring的DataAccessExceptions.Quick Setup快速开始To use MyBatis with Spring you need at least two things defined in the Spring application context: an SqlSessionFactory and at least one data mapper class. In MyBatis-Spring, an SqlSessionFactoryBean is used to create an SqlSessionFactory. To configure the factory bean, put the following in the Spring XML configuration file:为了能够使用MyBatis和Spring，我们至少需要在Spring 应用上下文中定义两个东西：一个SqlSessionFactory和至少一个数据映射器类。

MVC框架中英文对照外文翻译文献

MVC框架中英⽂对照外⽂翻译⽂献中英⽂对照外⽂翻译⽂献(⽂档含英⽂原⽂和中⽂翻译)译⽂：Web 2.0下的Spring MVC框架摘要 - 当要建⽴丰富⽤户体验的WEB应⽤时，有⼤量的WED应⽤框架可以使⽤，却很少有该选择哪⼀种的指导。

WEB 2.0应⽤允许个体管理他们⾃⼰的在线⽹页，并能与其他在线⽤户和服务器共享。

这样分享需要访问控制器来实现。

然⽽，现有的访问控制器解决⽅案不是令⼈很满意。

因为在开放且由⽤户主导的WEB环境下，它满⾜不了⽤户的功能需求。

MVC框架是在所有的WEB开发框架中最受欢迎的。

模型-视图-控制器（MVC）是⼀种软件架构，如今被认为是⼀种体系结构在软件⼯程模式中使⽤。

该模式从⽤户界⾯（输⼊和演⽰）分离出了“领域逻辑”（基于⽤户的应⽤逻辑），它允许独⽴地开发，测试和维护每个分离的部分。

模型-视图-控制器（MVC）模型创建的应⽤分离为不同的层次应⽤，同时在每两者之间建⽴松散的耦合。

关键字 - Spring MVC, 结构， XStudio, SOA, 控制器I.绪论如何确切地定义⼀个⽹站为“WEB 2.0”的呢？关于这有着许多不同见解，使它很难精确地下⼀个确切的定论。

但当我们将所有的WEB开发框架过⼀遍之后它就会变得清晰了。

各种基于WEB开发的架构如下：●Ntier架构（Ntier Architecture）在软件⼯程中，多层架构（常被称为n-tier架构）是⼀种表⽰层，应⽤处理层和数据管理层在逻辑上分开处理的客户端-服务器架构。

例如，⼀个应⽤在⽤户与数据库之间使⽤中间件提供数据请求服务就⽤到了多层体系结构。

最为⼴泛应⽤的多层体系结构是三层架构。

N-tier 应⽤架构为开发者提供了⽤来创建了⼀个灵活且可复⽤的模型。

通过打破应⽤层次，开发者只需修改或添加⼀个特定的层，⽽不是要去重写⼀遍整个应⽤。

它需要有⼀个表⽰层，⼀个业务层或者数据访问层和⼀个数据层。

层（layer）和层(tier)之间的概念常常是可以互换的。

spring官网在线学习文档翻译5

spring官⽹在线学习⽂档翻译55. Aspect Oriented Programming with Spring(使⽤Spring进⾏⾯向切⾯编程)5.1. Introduction(⼊门)Aspect-Oriented Programming (AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about program structure. The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. Aspects enable the modularization of concerns such as transaction management that cut across multiple types and objects. (Such concerns are often termed crosscutting concerns in AOP literature.)⾯向⽅⾯程序设计(AOP)通过提供另⼀种考虑程序结构的⽅法来补充⾯向对象程序设计(OOP)。

OOP中模块性的关键单元是类，⽽AOP中模块性的单元是⽅⾯。

⽅⾯⽀持关注点的模块化，例如跨多个类型和对象的事务管理。

(在AOP⽂献中，这样的关注点通常被称为横切关注点。

)One of the key components of Spring is the AOP framework. While the Spring IoC container does not depend on AOP, meaning you do not need to use AOP if you don’t want to, AOP complements Spring IoC to provide a very capable middleware solution.Spring的关键组件之⼀是AOP框架。

外文翻译-Spring的web-MVC-构架模式-精品

外文翻译-Spring的web-MVC-构架模式-精品2020-12-12【关键字】方案、情况、方法、领域、文件、模式、运行、传统、地方、问题、矛盾、系统、机制、良好、执行、发展、建立、提出、掌握、特点、关键、思想、基础、需要、环境、项目、体系、需求、方式、标准、结构、最大限度、任务、反映、关系、设置、分析、简化、丰富、管理、鼓励、维护、确保、服务、帮助、支持、解决、加快、完善、适应、实现、提高、协调、规范、核心Spring的web MVC 构架模式Juergen Hoeller1.介绍：Spring 应用构架当你第一次看到Spring的时候，你一定会说:"哦不，又一种web 构架".这篇文章将告诉你Spring明显区别于其他轻量级application framework, 它将专注于web的支持，与struts 和 webwork有着明显的区别。

在和struts 和 webwork的对比上,Spring是一个服务于所有层面的application framework:提供了bean的配置基础，AOP的支持，JDBC的提取框架，抽象事务支持，等等。

它有一个非常显著的特点：在某个层面上如果你不需要Spring的支持，你就可以不使用String的class，只使用它的某一部分的功能。

从它的设计理念，你可以看到String 帮助你实现了真正的逻辑层和web层的分离：例如。

一个校验应用将不用依靠controllers，就可以实现。

这样的目标是更好的重用和易测：过分依靠不必要的容器和框架将不能实现这一点。

当然,Spring 的自己的web支持和通常框架模式的细致完整.然而，Spring 替换struts,webwork或者其他的web方案非常的容易.对于Spring的web支持或者不同的地方，Spring 允许你在web容器里面建立一个中间层，在测试环境或者标准独立的应用里面来设置重用你的商务逻辑.还有在J2EE环境里面，你的商务逻辑不必依靠容器提供的服务，像JTA ,EJB的支持.良好的构架的web应用可以运行在任何容器上，如，Tomcat 或者 Resin. 值得注意的是，Spring 不是和已经存在的解决方案进行竞争. 我们鼓励结合标准的技术，如， Servlet, JSP, JTA, JNDI, JDBC, and JDO, 和非常匹配的工具，如，Hibernate, Velocity, Log4J, and Caucho's Hessian/Burlap.这个框架的的设计思想是在你的应用需要改良的时候，你将会做一些技术的选择:例如,如果你需要分布式事务处理，你可能需要用Spring的Jta TransactionManager 来实现JTA服务.或者，用DataSourceTransactionManager or HibernateTransactionManager 来实现美妙完美的单个数据库交换。

Spring中文翻译

Spring中⽂翻译Spring IoC 容器1.1 IoC Container 和 Bean 介绍控制反转（Inversion of Control，IoC ）也被称为依赖注⼊（Dependency Injection，DI）。

这是⼀个，多个对象仅仅通过构造器参数，⼯⼚⽅法参数，或者对象实例在被构造器初始化或者被⼯⼚⽅法创建返回之后设置属性来定义它们之间的依赖关系（对象之间的调⽤关系）的过程。

容器在它创建 bean 之后，注⼊之间的依赖项。

这个过程和 bean 本⾝通过使⽤类的直接构造器或服务定位机制，来控制其依赖项的实例化或位置，基本上是相反的（因此被称为控制反转）。

由⼈为的new新建对象，⾃⾏控制对象的实例和调⽤关系，转为容器控制。

控制⽅发⽣改变所以是控制反转org.springframework.beans和org.springframework.context是 Spring IoC 容器的基础BeanFactory接⼝，提供了管理任何类型对象的⾼级配置机制ApplicationContext是BeanFactory的⼀个⼦接⼝。

补充更简单与 Spring 的 AOP 特性集成信息资源处理（⽤于国际化）事件发布应⽤层特定的上下⽂。

（例如WebApplicationContext在 Web 应⽤程序中的使⽤）简单的说，BeanFacotry提供了配置框架和基础功能。

ApplicationContext增加了更多的企业特定的功能。

ApplicationContext是BeanFactory的⼀个完整的超集。

在 Spring 中，构成应⽤程序主⼲并且被 Spring IoC 容器所管理的，被称为 beans。

⼀个 bean 是被 Spring IoC 容器实例化，组装和管理的⼀个对象。

不然，bean 仅仅只是你应⽤程序中众多对象中的⼀个。

Beans，之间的依赖关系由容器使⽤的配置元素据所体现。

语篇翻译角度的SPRING译文赏析——以宋德利译文为例

86现代交际·2019年18期[作者简介]张歆闵，南京信息工程大学翻译硕士在读，研究方向：英语笔译。

语篇翻译角度的SPRING 译文赏析——以宋德利译文为例张歆闵(南京信息工程大学文学院江苏南京 210044)摘要：语篇是语言交际中的意义单位。

在翻译实践中，散文翻译等文学样式的翻译多采用语篇作为翻译单位。

语篇翻译应更加注重语篇的一致性、重点突出和衔接连贯三个方面。

以美国作家詹姆斯•J.凯尔帕特利克的散文SPRING 和宋德利先生对其的译文为例，分别说明这三方面在散文翻译中的具体体现和运用。

关键词：语篇翻译翻译单位转换衔接连贯中图分类号：H315.9 文献标识码：A 文章编号：1009—5349（2019）18—0086—03语篇是人们运用语言系统进行交流的段落结构，是表达中实际使用的语义单位。

传统意义上，任何一段口头语言或书面文字，或长或短，即使其内在的语言特征不同，只要这个片段能够构成一个语义整体，即能够相对完整地表达一定的意义，这样的片段都可以被称作语篇（董晓华，2018：24）。

在语篇翻译过程中，译者最重要的工作就是要确保原文语篇中承载的中心信息、主要思想和内容能够顺利传达（司显柱，2002：71）。

翻译文学作品时，语篇作为翻译单位，在散文翻译和其他文学样式的翻译中适用性更强。

在语篇翻译实践中，译者需要结合全语篇的整体状况，运用比较巧妙的方法和精确的词语，恰当地表达出原文的主旨内容，传递出原作者的思想情感。

因此，文学翻译在实践中应该树立明确的语篇意识，译者应从语篇的层面出发，纵览全文，使译文与原文更加契合。

本文将以美国作家詹姆斯•J.凯尔帕特利克（James J.Kilpatrick）的散文SPRING 和宋德利先生对其的译文为例，具体说明语篇的一致性、突出重点和衔接连贯这三个方面在翻译活动中的具体体现和运用。

一、把握文章主题，保证语篇一致性语篇的一致性，指的是整个语篇必须围绕一个中心或主题，尽管表述的角度或方式可能略有差别，但从始至终不能偏离这个中心主题。

关于Spring和ProverbsinLatinAmericanTalk翻译的比较

关于Spring和Proverbs in Latin American Talk翻译的比较韩舒亚 G1******* 08英语三班著名翻译学者张培基曾在《英汉翻译教程》中总结说，翻译是一种融理论、技能、艺术于一体的语言实践活动。

的确，仅仅从Spring和Proverbs in Latin American Talk这两篇文章的翻译中翻译的特点就展现的淋漓尽致。

两篇文章虽然篇幅不长，但在翻译过程中却运用了多种翻译理论、翻译技巧，也在一定程度上挑战了初级译者的理解力和表达力。

翻译，作为一项历史悠久的学科，其理论发展到今天可谓数不胜数。

无数学者、专家对翻译理论的总结归纳做出了自己的贡献。

其中，最有名最具代表性的莫过于19世纪末著名翻译家严复在《天演论•译例言》（1898）中，提出了“信、达、雅”（faithfulness, expressiveness and elegance）三字标准：“译事三难：信、达、雅。

求其信已大难矣，故信矣不达，虽译尤不译也，则达尚焉。

所以，Spring和Proverbs in Latin American Talk(下简称Proverbs)二文不论在其他方面又怎样的不同，遵循翻译的三原则，将其译成信达雅的文章还是最基本的要求的。

翻译理论的详细内容这里不再一一赘述，在下面的分析阐释中会有所体现。

总的来说，Spring和Proverbs的翻译区别主要体现在文体风格，内容方面；在技巧方面还是有些相同之处的。

1.文体风格文体风格的不同对文本的翻译有着举足轻重的影响。

英国著名散文家Lord Chesterfield 曾说:“Style is the dress of thoughts , and well –dressed thought , like a well - dressed man , appears to good advantage. ”(风格乃是思想的衣服,而穿着好的思想就像一个穿着好的人一样,可以显得大为生色) ①这足以说明风格的重要。

基于SpringBoot+Mybatis+Vue的学生德育量化考核系统设计与实现

基于SpringBoot+Mybatis+Vue的学生德育量化考核系统设计与实现基于Spring Boot+Mybatis+Vue的学生德育量化考核系统设计与实现导言近年来，随着人工智能和大数据的快速发展，学生德育教育也越来越受到重视。

为了更好地管理和评估学生的德育情况，学校需要建立一套科学合理的学生德育量化考核系统。

本文基于Spring Boot+Mybatis+Vue技术，设计并实现了一套学生德育量化考核系统，旨在提高学校德育工作的效率和质量。

一、需求分析学生德育量化考核系统的主要功能包括：学生信息管理、德育活动管理、德育考核管理、数据分析与报表等。

1. 学生信息管理学生信息管理模块实现学生基本信息的录入、修改、查询和删除。

学生基本信息包括学号、姓名、性别、年级、班级等。

2. 德育活动管理德育活动管理模块用于管理学生的德育活动。

教师可以录入和编辑德育活动信息，包括活动名称、活动时间、活动内容等。

学生可以查看已发布和参与的德育活动，并进行报名。

3. 德育考核管理德育考核管理模块用于对学生的德育表现进行评估和考核。

教师可以为学生添加考核项，并设置不同考核项的权重。

学生可以查看自己的考核成绩和排名。

4. 数据分析与报表数据分析与报表模块用于对学生德育情况进行统计和分析。

教师和管理员可以生成不同维度的报表，如学生德育水平分布图、班级德育排名表等。

二、系统设计基于上述需求，本系统的技术架构选择了Spring Boot作为后端框架，Mybatis作为ORM框架，Vue作为前端框架。

1. 后端设计后端采用了基于RESTful风格的接口设计，提供各种功能的API接口供前端调用。

采用Spring Boot框架开发后端业务逻辑，使用Mybatis框架操作数据库。

同时，为了提高系统的可扩展性和性能，采用Redis作为缓存组件。

2. 前端设计前端使用Vue框架进行开发，采用了Element UI作为UI组件库，使用axios库进行前后端数据交互。

毕业论文外文翻译-Spring的web MVC 构架模式

Web MVC with the Spring FrameworkJuergen Hoeller1. Introduction: Spring the Application FrameworkWhen first confronted with the Spring Framework, one might be tempted to think: "Oh no, not yet another web framework". This article will outline why Spring isn't particularly a web framework but a generic lightweight application framework with dedicated web support, and show the architectural differences to Struts and WebWork In contrast to Struts or WebWork, Spring is an application framework for all layers: It offers a bean configuration foundation, AOP support, a JDBC abstraction framework, abstract transaction support, etc. It is a very non-intrusive effort: Your application classes do not need to depend on any Spring classes if not necessary, and you can reuse every part on its own if you like to. From its very design, the framework encourages clean separation of tiers, most importantly web tier and business logic: e.g. the validation framework does not depend on web controllers. Major goals are reusability and testability: Unnecessary container or framework dependencies can be considered avoidable evils.Of course, Spring's own web support is nicely integrated with the framework's general patterns. Nevertheless, replacing the web solution with Struts, WebWork, or the like is easy. Both with Spring's web support or a different one, Spring allows for building a true dedicated middle tier in the web container, with the option to reuse exactly the same business logic in test environments or standalone applications. And within J2EE, your business logic will not unnecessarily depend on container services like JTA or EJB - allowing complex, well-architected web applications to run in a "simple" container like Tomcat or Resin.Note that Spring doesn't generally aim to compete with existing solutions. It rather fosters seamless integration with standards like Servlet, JSP, JTA, JNDI, JDBC, and JDO, and well-suited tools like Hibernate, Velocity, Log4J, and Caucho's Hessian/Burlap. The framework is designed to grow with the needs of your applications, in terms of technology choice: For example, you will probably use JTA via Spring's JtaTransactionManager if you need distributed transactions - but only then, as there are perfect replacements for single databases, like DataSourceTransactionManager or HibernateTransactionManager.2. Web MVC: The Design of Spring's Web FrameworkSpring's web framework is designed around a DispatcherServlet that dispatches requests to handlers, with configurable handler mappings, view resolution, and locale and theme resolution. The default handler is a very simple Controller interface, just offering a "ModelAndView handleRequest(request,response)" method. This can already be used for application controllers, but you will prefer the included implementation hierarchy, consisting of AbstractController, AbstractCommandController, MultiActionController, SimpleFormController, AbstractWizardFormController. Application controllers will typically be subclasses of those. Note that you can choose an appropriate base class: If you don't have a form, you don't need a FormController. This is a major difference to Struts.You can take any object as command or form object: There's no need to implement an interface or derive from a base class. Spring's data binding is highly flexible, e.g. it treats type mismatches as validation errors that can be evaluated by the application, not as system errors. So you don't need to duplicate your business objects' properties as Strings in your form objects, just to be able to handle invalid submissions, or to convert the Strings properly. Instead, it's often preferable to bind directly to your business objects. This is another major difference to Struts which is built around required base classes like Action and ActionForm - for every type of action. Compared to WebWork, Spring has more differentiated object roles: It supports the notion of a Controller, an optional command or form object, and a model that gets passed to the view. The model will normally include the command or form object but also arbitrary reference data. Instead, a WebWork Action combines all those roles into one single object. WebWork does allow you to use existing business objects as part of your form, but just by making them bean properties of the respective Action class. Finally, the same Action instance that handles the request gets used for evaluation and form population in the view. Thus, reference data needs to be modelled as bean properties of the Action too. These are arguably too many roles in one object.Regarding views: Spring's view resolution is extremely flexible. A Controller implementation can even write a view directly to the response, returning null as ModelAndView. In the normal case, a ModelAndView instance consists of a view name and a model Map, containing bean names and corresponding objects (like a command or form, reference data, etc). View name resolution is highly configurable, either via bean names, via a properties file, or via your own ViewResolver implementation. The abstract model Map allows for complete abstraction of the view technology, without any hassle: Be it JSP, Velocity, or anything else - every renderer can be integrated directly. The model Map simply gets transformed into an appropriate format, like JSP request attributes or a Velocity template model.3. Integration: Using a Different Web Framework with SpringMany teams will try to leverage their investments in terms of know-how and tools, both for existing projects and for new ones. Concretely, there are not only a large number of books and tools for Struts but also a lot of developers that have experience with it. Thus, if you can live with Struts' architectural flaws, it can still be a viable choice for the web layer. The same applies to WebWork and other web frameworks. If you don't want to use Spring's web MVC but intend to leverage other solutions that Spring offers, you can integrate the web framework of your choice with Spring easily. Simply start up a Spring root application context via its ContextLoaderListener, and access it via its ServletContext attribute (or Spring's respective helper method) from within a Struts or WebWork action. Note that there aren't any "plugins" involved, therefore no dedicated integration: From the view of the web layer, you'll simply use Spring as a library, with the root application context instance as entry point. All your registered beans and all of Spring's services can be at your fingertips even without Spring's web MVC. Spring doesn't compete with Struts or WebWork in this usage, it just addresses the many areas that the pure web frameworks don't, from beanconfiguration to data access and transaction handling. So you are able to enrich your application with a Spring middle tier and/or data access tier, even if you just want to use e.g. the transaction abstraction with JDBC or Hibernate.4. Feature Check ListIf just focussing on the web support, some of Spring's unique features are: .Clear separation of roles: controller vs validator vs command object vs form object vs model object, DispatcherServlet vs handler mapping vs view resolver, etc. .Powerful and straightforward configuration of both framework and application classes as JavaBeans, including easy in-between referencing via an application context, e.g. from web controllers to business objects and validators. .Adaptability, non-intrusiveness: Use whatever Controller subclass you need (plain, command, form, wizard, multi action, or a custom one) for a given scenario instead of deriving from Action/ActionForm for everything. .Reusable business code, no need for duplication: You can use existing business objects as command or form objects instead of mirroring them in special ActionForm subclasses. .Customizable binding and validation: type mismatches as application-level validation errors that keep the offending value, localized date and number binding, etc instead of String-only form objects with manual parsing and conversion to business objects. Customizable handler mapping, customizable view resolution: flexible model transfer via name/value Map, handler mapping and view resolution strategies from simple to sophisticated instead of one single way. Customizable locale and theme resolution, support for JSPs with and without Spring tag library, support for JSTL, support for Velocity without the need for extra bridges, etc. Simple but powerful tag library that avoids HTML generation at any cost, allowing for maximum flexibility in terms of markup code.翻译文稿Spring的web MVC 构架模式Juergen Hoeller1. 介绍：Spring 应用构架当你第一次看到Spring的时候，你一定会说:"哦不，又一种web 构架".这篇文章将告诉你Spring明显区别于其他轻量级application framework, 它将专注于web 的支持，与struts 和webwork有着明显的区别。

MyBatis-Spring Reference Simplied Chinese

本文档由南磊（nanlei1987@）翻译目录第一章介绍 (3)1.1 为什么整合MyBatis和Spring (3)1.2 要求 (3)1.3 感谢 (3)第二章入门 (4)2.1 介绍 (4)2.2 安装 (4)2.3 创建SqlSessionFactory (4)第三章注入映射器 (5)3.1 注入映射器 (5)第四章使用SqlSessionDaoTemplate和SqlSessionDaoSupport (6)4.1 SqlSessionDaoTemplate (6)4.2 SqlSessionDaoSupport (6)第五章使用MyBatis API (7)5.1 使用MyBatis API (7)第六章示例代码 (8)6.1 示例代码 (8)第一章介绍1.1 为什么整合MyBatis和Spring每个Spring的用户都曾不耐烦地等待3.X版本的发布，但不幸的是，这让MyBatis用户相当失望：发布时没有对MyBatis这一优秀的SQL映射框架提供支持。

在Spring的JIRA问题列表中，很多要求整合和发布补丁的请求，虽然被接受但是也被延迟处理了。

MyBatis社区认为现在应该是自己团结贡献者和有兴趣的人一起来开始进行Spring和MyBatis整合的时候了。

所以这个小类库就来创建丢失的粘贴Spring和MyBtatis这两个流行框架的胶水。

减少用户不得不来配置MyBatis和Spring 3.X上下文环境的样板和冗余代码。

1.2 要求在开始阅读本手册之前，很重要的一点是你要熟悉Spring和MyBatis这两个框架还有和它们有关的术语，否则可能会很难理解手册中的表述内容。

毕业论文英文翻译

毕业论文英文翻译把汉语译成英语或把英语译成汉语是一种语言活动，它既涉及汉英两种语言本身的知识，也涉及多方面的文化背景知识。

下文是店铺为大家整理的关于英文翻译毕业论文的内容，欢迎大家阅读参考!英文翻译毕业论文篇1英文翻译本质浅析【摘要】尽管翻译是人类最早从事的智力活动之一，但是对“翻译到底是什么”这个本质的问题人们至今也没达成共识。

实际上，译学上的许多重大问题，如翻译的标准问题、直译或意译的问题、翻译是科学还是艺术的问题，最终都可以归结为对翻译本质认识的不同。

笔者在拜读过一篇篇高论后，认识到对翻译本质的讨论集中起来涉及两点，一是翻译是一种怎样的活动，二是翻译是一种什么性质的活动;前者讨论翻译的定义，后者涉及翻译的概念、分类和性质。

【关键词】英文翻译定义性质一、翻译的定义许多人曾为翻译下过定义。

卡特福德给翻译下的定义是：the replacement of textual material in one language (SL)by equivalent textual material in another language (TL)。

(Catford，1965)即“一种语言(译出语)的话语材料被另一种语言(译入语)中的对等的话语材料替代”。

在这里，翻译似乎主要是两种存在状态，一种是源语，一种是译语，既不讲翻译主体，也没有提到翻译过程，很难说它说中了翻译活动的实质。

费道罗夫认为“翻译是用一种语言手段忠实、全面地表达另一种语言表达的东西。

”可以看出上面定义中的等值论观点来自费道罗夫的“忠实”、“全面”。

在揭示翻译活动的本质方面，它们都有一个共同的缺点，就是没能明示翻译与其实活动的根本区别。

其实，摘译、编译等活动都是翻译，因为上述活动都主要表现为语言间的意义转换。

在对翻译本质的认识上，威尔斯比以上二位又进了一步：“翻译是将源语话语变为尽可能等值的译语话语的过程”。

(蔡毅，1995)这里没有硬性规定，只是说“尽可能等值”。

Spring框架-毕业论文外文文献翻译

外文文献翻译SpringFrameworkSpring is an open source framework, and Spring was launched in 2003 as a lightweight Java development framework created by Rod Johnson.In a nutshell, Spring is a hierarchical, JavaSE/EEfull-stack (one-stop) lightweight open source framework.The powerful JavaBeans based configuration management using the Inversion of Control (IoC) principle makes application components faster and easier.1.facilitate decoupling and simplify developmentThrough the IoC container provided by Spring, we can control dependencies between objects by Spring, avoiding excessive program coupling caused by hard coding.With Spring, users do not have to write code for the bottom tier requirements of single instance schema classes, properties, file parsing, and so on, and can focus more on top tier applications.2.AOP programming supportThrough the Spring functionality provided by AOP, it is easy to implement face oriented programming, and many features that are not easily implemented with traditional OOP can be easily handled by AOP.3.declarative transaction supportIn Spring, we can extricate ourselves from tedious and tedious transaction management code and flexibly manage the transaction through declarative manner, so as to improve the efficiency and quality of development.4.convenience program testingAlmost all test work can be done in a non container dependent programming manner, and in Spring, testing is no longer expensive, but something to do.For example, Spring supports Junit4 and can easily test Spring programs by annotations.5.convenient integration of various excellent frameworkSpring does not exclude all kinds of excellent open source framework, on the contrary, Spring can reduce the difficulty of the use of Spring framework, provides a framework for a variety of excellent (such as Struts, Hibernate, Hessian, Quartz) directly support the.6.reduce the difficulty of using Java EE APISpring provides a thin layer of encapsulation for many difficult Java, EE, API (such as JDBC, JavaMail, remote calls, etc.), and the use of these Java EE API is greatly reduced through the simple package of Spring.7.Java source code is a classic example of learningSpring source code, clear structure, exquisite design originality, embodies the master of the Java design pattern and the flexible use of Java technology accomplishment.Spring framework source code is undoubtedly the best practice example of Java technology.If you want to quickly improve your Java skills and application development level in a short time, learning an.The role of MVC - Spring is integration, but not just integration, and the Spring framework can be seen as a framework for enterprise solution levels.The client sends a request, the server controller (implemented by DispatcherServlet) to complete the request forwarding, call a controller for mapping class HandlerMapping, the class is used to map requests to the corresponding processor to process the request.HandlerMapping will request is mapped to the corresponding processor Controller (equivalent to Action) in Spring if you write some processor components, the general implementation of the Controller interface in Controller, you can call Service or DAO to operate data from the DAO ModelAndView used to store the retrieved data, some data can also be stored in response to the view.If you want to return the result to the user, it also provides a view of ViewResolver component in Spring framework, the component labeled Controller returns according to, find the corresponding view, the response response back to the user.Each module (or component) that makes up the Spring framework can exist alone, or can be implemented in conjunction with one or more other modules.Each module has the following functions: 1, the core container: the core container provides the basic functionality of the Spring framework (Spring, Core).The main component of the core container is BeanFactory, which is implemented in factory mode.BeanFactory uses the control inversion (IOC) pattern to separate application configuration and dependency specifications from theactual application code.Spring框架Spring是一个开源框架, Spring是于2003 年兴起的一个轻量级的Java 开发框架, 由Rod Johnson创建。

翻译对比分析

1.从我们自己这些年的经验来看，经济发展隔几年上一个台阶，是能够办得到的。

《北京周报》译文：Viewed from the experience of recent years, economic development can reach a new stage every few years.外文出版社译文：Judging from what we have accomplished in recent years, it should be possible for our economy to reach a new stage every few years.<1>分析：《北京周报》的译文采用了直译的语言表达形式，主句主语选用economic development外文出版社的译文采用具体译法，将抽象的“经验”用what we have accomplished 表达，用it做形式主语，其真正主语是economy2.有了这一条，中国就大有希望。

《北京周报》译文：Then, there will be great hopes for China.外文出版社译文：Then, the prospects for China will be excellent.<1>原文中“有了这一条”两种译文都用了省词译法，直接用了“then”，既简洁又联系了上下文。

<2>原文中“中国大有希望”，前译文用了直译法，运用“there be”句式；后译文用了增词译法“the prospects for China”，同时以其为主语，译成“中国的发展很有希望”，符合英语语法习惯。

3.在这短短的十几年内，我们国家发展得这么快，使人民高兴，世界瞩目。

《北京周报》译文：In the short span of the past 10-plus years, the rapid development of our country has delighted the people and focused world attention.外文出版社译文：In the short span of the last dozen years, the rapid development of our country has delighted the people and attracted world attention.<1>这两句都运用了词法翻译中的转性译法，把原文中的动词转化为了名词。

Mybatis-Spring源码分析图解

Mybatis-Spring源码分析图解Mybatis-Spring当我们使⽤mybatis和spring整合后为什么下⾯的代码可以运⾏?⼀个问题:我就写了个mapper接⼝为什么能⽤?⾸先来看,在spring的配置xml中有⼀段<bean id="configurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/><property name="basePackage" value="com.jame.dao"/></bean>这段xml的作⽤是将⼀个类添加到spring容器中,点进这个类看看它实现了⼀个BeanDefinitionRegistryPostProcessor接⼝,,这⾥就不再赘述那么它必然实现postProcessBeanDefinitionRegistry⽅法,点击这个⽅法查看@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {if (this.processPropertyPlaceHolders) {processPropertyPlaceHolders();}ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);..........scanner.registerFilters();scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));}其中将接⼝注册到spring容器中在最后⼀⾏,先来看ClassPathMapperScanner这个类,它继承了ClassPathBeanDefinitionScanner这个扫描器scan的具体代码public int scan(String... basePackages) {int beanCountAtScanStart = this.registry.getBeanDefinitionCount();doScan(basePackages);// Register annotation config processors, if necessary.if (this.includeAnnotationConfig) {AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);}return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);}这个是spring内部的扫描⽅法,当它⾛到doScan的时候,因为ClassPathMapperScanner这个类重写了doScan⽅法,所以会调⽤⼦类重写的⽅法@Overridepublic Set<BeanDefinitionHolder> doScan(String... basePackages) {Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);if (beanDefinitions.isEmpty()) {LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages)+ "' package. Please check your configuration.");} else {processBeanDefinitions(beanDefinitions);}return beanDefinitions;}通过包名获取BeanDefinitionHolder,现在它获取到了User接⼝的BeanDefinitionHolder,然后判断如果BeanDefinitionHolder的集合为空,也就是没有找到mapper的情况则不做任何处理,⽽现在有⼀个UserMapper的,进⼊elseprivate void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {AbstractBeanDefinition definition;BeanDefinitionRegistry registry = getRegistry();for (BeanDefinitionHolder holder : beanDefinitions) {definition = (AbstractBeanDefinition) holder.getBeanDefinition();.........//主要看这⾏definition.setBeanClass(this.mapperFactoryBeanClass);.........if (!definition.isSingleton()) {BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(holder, registry, true);if (registry.containsBeanDefinition(proxyHolder.getBeanName())) {registry.removeBeanDefinition(proxyHolder.getBeanName());}registry.registerBeanDefinition(proxyHolder.getBeanName(), proxyHolder.getBeanDefinition());}}}将MapperFactoryBean类设置为了UserMapperBeanDefinition的classspring在创建这个userMapper这个Bean的时候会使⽤这个有参构造将当前这个UserMapper类型设置到mapperInterface属性上(为啥使⽤有参构造⽽不是⽆参来初始化对象我也不知道.....这和spring推断构造⽅法有关,以后学会了在来写)这个MapperFactoryBean实现了⼀个FactoryBean接⼝,这个接⼝可以让我们⾃定义获取bean的操作回到spring的代码,例如当我们使⽤context.getBean(xxx.class)的时候spring将xxx.class类型解析为bean名称,通过名称去获取protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {//获取对应的beanNameString beanName = transformedBeanName(name);Object bean;Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);}.......// Create bean instance.if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {//真正创建对象的地⽅return createBean(beanName, mbd, args);}catch (BeansException ex) {// Explicitly remove instance from singleton cache: It might have been put there// eagerly by the creation process, to allow for circular reference resolution.// Also remove any beans that received a temporary reference to the bean.destroySingleton(beanName);throw ex;}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}}⾸先是调⽤getSingleton⽅法,尝试获取存在缓存中的bean(其实就是三个Map,key为bean名称,value是对象),那现在是⾸次获取map中没有然后执⾏到下⾯的createBean,当创建完这个bean后spring需要判断这个bean是⼀个普通bean还是⼀个FactoryBean,程序员是想要获取普通bean还是FactoryBean,还是FactoryBean的getObject⽅法返回的从⼯⼚⽣成的对象咱们⼀段⼀段看protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {if (BeanFactoryUtils.isFactoryDereference(name)) {if (beanInstance instanceof NullBean) {return beanInstance;}if (!(beanInstance instanceof FactoryBean)) {throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());}}.....}BeanFactoryUtils.isFactoryDereference(name)的作⽤是⼀个字符串判断,当返回传⼊名称是否为⼯⼚,如果name不为空,并且以&开头返回true这个⽅法在下⾯的判断也使⽤到了,记⼀下它的作⽤即可来看例⼦在我们使⽤FactoryBean通过context.getBean("⼯⼚Bean名称")的时候获取的是FactoryBean的getObject⽣成的对象,如果我们想获取FactoryBean的引⽤则需要在名称前⾯加⼀个&符号回来看代码,如果这个bean的引⽤是⼀个NullBean类型则直接返回引⽤,下⾯有做了⼀个判断if (!(beanInstance instanceof FactoryBean))再次判断这个bean是不是⼀个FactoryBean,如果为true则抛出异常,这个好理解,因为我们在getBean的时候完全可以将⼀个普通的bean名称前⾯加上&符号主要的判断在下⾯的这个ifif (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {return beanInstance;}现在有3中情况1.当前的bean是⼀个普通的bean第⼀个条件false 取反 true 第⼆个条件false 结果true,直接返回bean实例2.当前是⼀个FactoryBean,想通过⼯⼚获取Bean第⼀个条件 true 取反false 第⼆个条件false 结果false,进⾏下⾯的操作3.当前是⼀个FactoryBean,想获取⼯⼚的引⽤第⼀个条件 true 取反 false 第⼆个条件 true 结果 true 直接返回factoryBean实例当前我们是想通过FactoryBean获取对象,那么不进if,继续下⾯的代码Object object = null;// 如果beanDefinition为null,则尝试从缓存中获取给定的FactoryBean公开的对象if (mbd == null) {//尝试从缓存中加载beanobject = getCachedObjectForFactoryBean(beanName);}// 未能从缓存中获得FactoryBean公开的对象,则说明该bean是⼀个新创建的beanif (object == null) {FactoryBean<?> factory = (FactoryBean<?>) beanInstance;if (mbd == null && containsBeanDefinition(beanName)) {mbd = getMergedLocalBeanDefinition(beanName);}boolean synthetic = (mbd != null && mbd.isSynthetic());// 从给定的FactoryBean中获取指定的beanName对象object = getObjectFromFactoryBean(factory, beanName, !synthetic);}return object;主要来看getObjectFromFactoryBeanprotected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {if (factory.isSingleton() && containsSingleton(beanName)) {synchronized (getSingletonMutex()) {Object object = this.factoryBeanObjectCache.get(beanName);if (object == null) {//调⽤factoryBean的getObject⽅法object = doGetObjectFromFactoryBean(factory, beanName);Object alreadyThere = this.factoryBeanObjectCache.get(beanName);if (alreadyThere != null) {object = alreadyThere;}}..........}}}doGetObjectFromFactoryBean⽅法private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {Object object;try {if (System.getSecurityManager() != null) {AccessControlContext acc = getAccessControlContext();try {object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);}catch (PrivilegedActionException pae) {throw pae.getException();}}else {//调⽤重写的getObject⽅法object = factory.getObject();}}.......return object;}也就是说当我们getBean("userMapper")的时候其实是调⽤FactoryBean的getObject⽅法,代码回到mybatis-spring项⽬的MapperFactoryBean类中的getObject⽅法@Overridepublic T getObject() throws Exception {return getSqlSession().getMapper(this.mapperInterface);}@Overridepublic <T> T getMapper(Class<T> type) {return configuration.getMapper(type, this);}public <T> T getMapper(Class<T> type, SqlSession sqlSession) {final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);if (mapperProxyFactory == null) {throw new BindingException("Type " + type + " is not known to the MapperRegistry.");}try {return mapperProxyFactory.newInstance(sqlSession);} catch (Exception e) {throw new BindingException("Error getting mapper instance. Cause: " + e, e);}}public T newInstance(SqlSession sqlSession) {final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);return newInstance(mapperProxy);}protected T newInstance(MapperProxy<T> mapperProxy) {return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);}到最后发现是通过jdk的动态代理来⽣成的对象,那么回答开始的问题我就写了个接⼝为什么能⽤?因为mybatis在spring加载bean之前修改了beanDefinition,通过MapperScannerConfigurer类实现的BeanDefinitionRegistryPostProcessor接⼝中将我们定义的⼀些mapper接⼝的BeanDefinition的BeanClass属性修改为了MapperFactoryBean,⽽这个类实现了FactoryBean,我们获取接⼝实际上是通过FactoryBean的getObject⽅法到此这篇关于Mybatis-Spring源码分析的⽂章就介绍到这了,更多相关Mybatis-Spring源码分析内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

spring boot外文文献

spring boot外文文献Spring Boot是一个开源的Java框架，用于快速构建独立的、基于Spring的应用程序。

它通过提供一系列的默认配置和约定来简化Spring应用程序的开发过程。

由于其简洁性和高效性，Spring Boot在近年来迅速成为Java应用程序开发的热门选择。

在开发过程中，掌握相关的外文文献对于理解和研究Spring Boot的原理和实践经验非常重要。

外文文献可以提供最新的研究成果、实际应用案例、最佳实践等信息，有助于开发者深入理解Spring Boot的各个方面。

本文档将为读者提供一系列的外文文献，旨在帮助读者更好地理解和运用Spring Boot框架。

通过阅读这些外文文献，读者可以了解Spring Boot的优点、功能特性、性能优化等方面的内容，从而提高自己的开发水平。

请注意，本文档中的引用内容可能需要读者自行查证。

本文档的目标是提供一个简要的综述，而非对内容进行详尽的总结。

本文介绍了Spring Boot框架以及其在软件开发中的应用。

Spring Boot是一个开源的Java框架，旨在简化Spring应用程序的开发和部署。

它提供了一种快速构建基于Spring的应用程序的方式，消除了传统Spring应用程序中繁琐的配置。

Spring Boot采用了约定优于配置的原则，可以轻松地创建独立的、可执行的Spring 应用，而无需手动配置大量的XML文件。

Spring Boot在软件开发中具有广泛的应用。

它可以用于开发各种类型的应用程序，包括Web应用、微服务、批处理应用等。

Spring Boot提供了许多开箱即用的特性和组件，例如自动配置、健康检查、安全性等，极大地提高了开发效率。

总之，Spring Boot框架简化了Spring应用程序的开发，减少了繁琐的配置，提高了开发效率。

它在软件开发中有着广泛的应用，可以帮助开发者快速构建高效、可靠的应用程序。

本文综述了已有的与Spring Boot相关的外文文献，并归纳了研究进展和主要成果。

【Mybatis源码解析】-mybatis-spring原理解析

【Mybatis源码解析】-mybatis-spring原理解析mybatis-spring原理解析没有spring使⽤Mybatis的步骤是1：创建SqlSessionFactoryBuilder2: 通过SqlSessionFactoryBuilder创建要给SqlSessionFactory3: 创建SqlSession4: 获取Mapper的代理对象5：执⾏获取结果很多都是重复步骤，可以交给spring去管理mybatis-spring就是帮助处理这些⼯作，Mybatis-spring主要做的内容包含：1. mybatis相关类 “Spring”化，都注册到Spring 容器中，对mapper额外提供批量扫描功能。

2. 事务对接Spring，SqlSession交由Spring事务管理。

我们从使⽤过程到执⾏过程分步讲解原理。

1、初始化过程⼊⼝：SqlSessionFactoryBean使⽤Mybatis-spring，需要主动配置SqlSessionFactoryBean，所以配置初始化的流程从这⾥开始。

SqlSessionFactoryBean实现了FactoryBean,InitializingBean,ApplicationListenerFactoryBean，⽤于⾃定义Bean实例化逻辑，并注册到Spring容器。

SqlSessionFactory是⼀个很重的类，实例的化的过程⽐较复杂繁琐。

ApplicationListener，监听的是ContextRefreshedEvent事件，配置了快速失败时检查MapperedStatement是否加载完毕。

InitializingBean，真正开始实例化的时机，开始构建SqlSessionFactory。

1.1、SqlSessionFactory初始化@Overridepublic void afterPropertiesSet() throws Exception {notNull(dataSource, "Property 'dataSource' is required");notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),"Property 'configuration' and 'configLocation' can not specified with together");// 开始构造this.sqlSessionFactory = buildSqlSessionFactory();}构造过程：也就是解析配置⽂件，构造Configuration过程protected SqlSessionFactory buildSqlSessionFactory() throws Exception {final Configuration targetConfiguration;XMLConfigBuilder xmlConfigBuilder = null;// 指定了mybatis-config.xml的路径时else if (this.configLocation != null) {// 构造xml解析器xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);targetConfiguration = xmlConfigBuilder.getConfiguration();}// 啥都没指定，直接实例化Configuration，使⽤默认配置else {LOGGER.debug(() -> "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");targetConfiguration = new Configuration();Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);}// 默认配置设置Optional.ofNullable(this.objectFactory).ifPresent(targetConfiguration::setObjectFactory);Optional.ofNullable(this.objectWrapperFactory).ifPresent(targetConfiguration::setObjectWrapperFactory);Optional.ofNullable(this.vfs).ifPresent(targetConfiguration::setVfsImpl);if (hasLength(this.typeAliasesPackage)) {scanClasses(this.typeAliasesPackage, this.typeAliasesSuperType).stream().filter(clazz -> !clazz.isAnonymousClass()).filter(clazz -> !clazz.isInterface()).filter(clazz -> !clazz.isMemberClass()).forEach(targetConfiguration.getTypeAliasRegistry()::registerAlias);}// 别名注册if (!isEmpty(this.typeAliases)) {Stream.of(this.typeAliases).forEach(typeAlias -> {targetConfiguration.getTypeAliasRegistry().registerAlias(typeAlias);LOGGER.debug(() -> "Registered type alias: '" + typeAlias + "'");});}// 插件注册if (!isEmpty(this.plugins)) {Stream.of(this.plugins).forEach(plugin -> {targetConfiguration.addInterceptor(plugin);LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");});}// ⾃定义类型处理器注册if (hasLength(this.typeHandlersPackage)) {scanClasses(this.typeHandlersPackage, TypeHandler.class).stream().filter(clazz -> !clazz.isAnonymousClass()) .filter(clazz -> !clazz.isInterface()).filter(clazz -> !Modifier.isAbstract(clazz.getModifiers())).forEach(targetConfiguration.getTypeHandlerRegistry()::register);}if (!isEmpty(this.typeHandlers)) {Stream.of(this.typeHandlers).forEach(typeHandler -> {targetConfiguration.getTypeHandlerRegistry().register(typeHandler);LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");});}if (!isEmpty(this.scriptingLanguageDrivers)) {Stream.of(this.scriptingLanguageDrivers).forEach(languageDriver -> {targetConfiguration.getLanguageRegistry().register(languageDriver);LOGGER.debug(() -> "Registered scripting language driver: '" + languageDriver + "'");});}Optional.ofNullable(this.defaultScriptingLanguageDriver).ifPresent(targetConfiguration::setDefaultScriptingLanguage);if (this.databaseIdProvider != null) {// fix #64 set databaseId before parse mapper xmlstry {targetConfiguration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));} catch (SQLException e) {throw new NestedIOException("Failed getting a databaseId", e);}}Optional.ofNullable(this.cache).ifPresent(targetConfiguration::addCache);// 执⾏了Config路径时需要解析if (xmlConfigBuilder != null) {try {xmlConfigBuilder.parse();LOGGER.debug(() -> "Parsed configuration file: '" + this.configLocation + "'");} catch (Exception ex) {throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);} finally {ErrorContext.instance().reset();}}targetConfiguration.setEnvironment(new Environment(this.environment,this.transactionFactory == null ? new SpringManagedTransactionFactory() : this.transactionFactory,this.dataSource));// mapper.xml⽂件地址if (this.mapperLocations != null) {if (this.mapperLocations.length == 0) {LOGGER.warn(() -> "Property 'mapperLocations' was specified but matching resources are not found.");} else {for (Resource mapperLocation : this.mapperLocations) {if (mapperLocation == null) {continue;}try {// 遍历解析xml并注册XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),targetConfiguration, mapperLocation.toString(), targetConfiguration.getSqlFragments());xmlMapperBuilder.parse();} catch (Exception e) {throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);} finally {ErrorContext.instance().reset();}LOGGER.debug(() -> "Parsed mapper file: '" + mapperLocation + "'");}}} else {LOGGER.debug(() -> "Property 'mapperLocations' was not specified.");}// 将设置好的Configuration交由SqlSessionFactoryBuilder进⾏构造return this.sqlSessionFactoryBuilder.build(targetConfiguration);}SqlSessionFactory就已经初始化完毕了，SqlSessionFactory的实例单例保存在Spring容器中，具体在Mybatis的哪个类中⾃动使⽤，稍后再说。

MyBatis-spring中文帮助文档

简介What is MyBatis-Spring?MyBatis-Spring 会帮助你将MyBatis 代码无缝地整合到Spring 中。

使用这个类库中的类, Spring 将会加载必要的MyBatis 工厂类和session 类。

这个类库也提供一个简单的方式来注入MyBatis 数据映射器和SqlSession 到业务层的bean 中。

而且它也会处理事务, 翻译MyBatis 的异常到Spring 的DataAccessException 异常(数据访问异常,译者注)中。

最终,它并不会依赖于MyBatis,Spring 或MyBatis-Spring 来构建应用程序代码。

Motivation正如第二版那样,Spring 3.0 也仅支持iBatis2。

那么,我们就想将MyBatis3 的支持添加到Spring3.0(参考Spring Jira 中的问题)中。

而不幸的是,Spring 3.0 的开发在MyBatis 3.0 官方发布前就结束了。

因为Spring 开发团队不想发布一个基于非发布版的MyBatis 的整合支持,那么Spring 官方的支持就不得不继续等待了。

要在Spring 中支持MyBatis,MyBatis 社区认为现在应该是自己团结贡献者和有兴趣的人一起来开始将Spring 的整合作为MyBatis 社区的子项目的时候了。

Requirements在开始使用MyBatis-Spring 的整合之前,很重要的一点是,你要熟悉Spring 和MyBatis 这两个框架还有和它们有关的术语,本手册中不会提供二者的基本内容,安装和配置教程。

MyBatis-Spring requires Java 5 or higher and the following MyBatis and Spring versions:特别感谢那些使得本项目成为现实的人们(按字母顺序排序)。

Eduardo Macarron, Hunter Presnall和Putthibong Boonbong的编码, 测试和文档修改工作; Andrius Juozapaitis, Giovanni Cuccu,Raj Nagappan和Tomas Pinos的贡献;而Simone Tripodi发现了这些人并把他们带入项目之中。