Spring和MyBatis的外文翻译..

合集下载

Spring相关的外文文献和翻译(毕设论文必备)

附录1 外文原文Introducing the Spring FrameworkThe Spring Framework: a popular open source application framework that addresses many of the issues outlined in this book. This chapter will introduce the basic ideas of Spring and dis-cuss the central “bean factory”lightweight Inversion-of-Control (IoC) container in detail.Spring makes it particularly easy to implement lightweight, yet extensible, J2EE archi-tectures. It provides an out-of-the-box implementation of the fundamental architectural building blocks we recommend. Spring provides a consistent way of structuring your applications, and provides numerous middle tier features that can make J2EE development significantly easier and more flexible than in traditional approaches.The basic motivations for Spring are:To address areas not well served by other frameworks. There are numerous good solutions to specific areas of J2EE infrastructure: web frameworks, persistence solutions, remoting tools, and so on. However, integrating these tools into a comprehensive architecture can involve significant effort, and can become a burden. Spring aims to provide an end-to-end solution, integrating spe-cialized frameworks into a coherent overall infrastructure. Spring also addresses some areas that other frameworks don’t. For example, few frameworks address generic transaction management, data access object implementation, and gluing all those things together into an application, while still allowing for best-of-breed choice in each area. Hence we term Spring an application framework, rather than a web framework, IoC or AOP framework, or even middle tier framework.To allow for easy adoption. A framework should be cleanly layered, allowing the use of indi-vidual features without imposing a whole world view on the application. Many Spring features, such as the JDBC abstraction layer or Hibernate integration, can be used in a library style or as part of the Spring end-to-end solution.To deliver ease of use. As we’ve noted, J2EE out of the box is relatively hard to use to solve many common problems. A good infrastructure framework should make simple tasks simple to achieve, without forcing tradeoffs for future complex requirements (like distributed transactions) on the application developer. It should allow developers to leverage J2EE services such as JTA where appropriate, but to avoid dependence on them in cases when they are unnecessarily complex.To make it easier to apply best practices. Spring aims to reduce the cost of adhering to best practices such as programming to interfaces, rather than classes, almost to zero. However, it leaves the choice of architectural style to the developer.Non-invasiveness. Application objects should have minimal dependence on the framework. If leveraging a specific Spring feature, an object should depend only on that particular feature, whether by implementing a callback interface or using the framework as a class library. IoC and AOP are the key enabling technologies for avoiding framework dependence.Consistent configuration. A good infrastructure framework should keep application configuration flexible and consistent, avoiding the need for custom singletons and factories. A single style should be applicable to all configuration needs, from the middle tier to web controllers.Ease of testing. Testing either whole applications or individual application classes in unit tests should be as easy as possible. Replacing resources or application objects with mock objects should be straightforward.To allow for extensibility. Because Spring is itself based on interfaces, rather than classes, it is easy to extend or customize it. Many Spring components use strategy interfaces, allowing easy customization.A Layered Application FrameworkChapter 6 introduced the Spring Framework as a lightweight container, competing with IoC containers such as PicoContainer. While the Spring lightweight container for JavaBeans is a core concept, this is just the foundation for a solution forall middleware layers.Basic Building Blockspring is a full-featured application framework that can be leveraged at many levels. It consists of multi-ple sub-frameworks that are fairly independent but still integrate closely into a one-stop shop, if desired. The key areas are:Bean factory. The Spring lightweight IoC container, capable of configuring and wiring up Java-Beans and most plain Java objects, removing the need for custom singletons and ad hoc configura-tion. Various out-of-the-box implementations include an XML-based bean factory. The lightweight IoC container and its Dependency Injection capabilities will be the main focus of this chapter.Application context. A Spring application context extends the bean factory concept by adding support for message sources and resource loading, and providing hooks into existing environ-ments. Various out-of-the-box implementations include standalone application contexts and an XML-based web application context.AOP framework. The Spring AOP framework provides AOP support for method interception on any class managed by a Spring lightweight container. It supports easy proxying of beans in a bean factory, seamlessly weaving in interceptors and other advice at runtime. Chapter 8 dis-cusses the Spring AOP framework in detail. The main use of the Spring AOP framework is to provide declarative enterprise services for POJOs.Auto-proxying. Spring provides a higher level of abstraction over the AOP framework and low-level services, which offers similar ease-of-use to .NET within a J2EE context. In particular, the provision of declarative enterprise services can be driven by source-level metadata.Transaction management. Spring provides a generic transaction management infrastructure, with pluggable transaction strategies (such as JTA and JDBC) and various means for demarcat-ing transactions in applications. Chapter 9 discusses its rationale and the power and flexibility that it offers.DAO abstraction. Spring defines a set of generic data access exceptions that canbe used for cre-ating generic DAO interfaces that throw meaningful exceptions independent of the underlying persistence mechanism. Chapter 10 illustrates the Spring support for DAOs in more detail, examining JDBC, JDO, and Hibernate as implementation strategies.JDBC support. Spring offers two levels of JDBC abstraction that significantly ease the effort of writing JDBC-based DAOs: the org.springframework.jdbc.core package (a template/callback approach) and the org.springframework.jdbc.object package (modeling RDBMS operations as reusable objects). Using the Spring JDBC packages can deliver much greater pro-ductivity and eliminate the potential for common errors such as leaked connections, compared with direct use of JDBC. The Spring JDBC abstraction integrates with the transaction and DAO abstractions.Integration with O/R mapping tools. Spring provides support classes for O/R Mapping tools like Hibernate, JDO, and iBATIS Database Layer to simplify resource setup, acquisition, and release, and to integrate with the overall transaction and DAO abstractions. These integration packages allow applications to dispense with custom ThreadLocal sessions and native transac-tion handling, regardless of the underlyingO/R mapping approach they work with.Web MVC framework. Spring provides a clean implementation of web MVC, consistent with the JavaBean configuration approach. The Spring web framework enables web controllers to be configured within an IoC container, eliminating the need to write any custom code to access business layer services. It provides a generic DispatcherServlet and out-of-the-box controller classes for command and form handling. Request-to-controller mapping, view resolution, locale resolution and other important services are all pluggable, making the framework highly extensi-ble. The web framework is designed to work not only with JSP, but with any view technology, such as Velocity—without the need for additional bridges. Chapter 13 discusses web tier design and the Spring web MVC framework in detail.Remoting support. Spring provides a thin abstraction layer for accessing remoteservices without hard-coded lookups, and for exposing Spring-managed application beans as remote services. Out-of-the-box support is included for RMI, Caucho’s Hessian and Burlap web service protocols, and WSDL Web Services via JAX-RPC. Chapter 11 discusses lightweight remoting.While Spring addresses areas as diverse as transaction management and web MVC, it uses a consistent approach everywhere. Once you have learned the basic configuration style, you will be able to apply it in many areas. Resources, middle tier objects, and web components are all set up using the same bean configuration mechanism. You can combine your entire configuration in one single bean definition file or split it by application modules or layers; the choice is up to you as the application developer. There is no need for diverse configuration files in a variety of formats, spread out across the application.Spring on J2EEAlthough many parts of Spring can be used in any kind of Java environment, it is primarily a J2EE application framework. For example, there are convenience classes for linking JNDI resources into a bean factory, such as JDBC DataSources and EJBs, and integration with JTA for distributed transaction management. In most cases, application objects do not need to work with J2EE APIs directly, improving reusability and meaning that there is no need to write verbose, hard-to-test, JNDI lookups.Thus Spring allows application code to seamlessly integrate into a J2EE environment without being unnecessarily tied to it. You can build upon J2EE services where it makes sense for your application, and choose lighter-weight solutions if there are no complex requirements. For example, you need to use JTA as transaction strategy only if you face distributed transaction requirements. For a single database, there are alternative strategies that do not depend on a J2EE container. Switching between those transac-tion strategies is merely a matter of configuration; Spring’s consistent abstraction avoids any need to change application code.Spring offers support for accessing EJBs. This is an important feature (andrelevant even in a book on “J2EE without EJB”) because the use of dynamic proxies as codeless client-side business delegates means that Spring can make using a local stateless session EJB an implementation-level, rather than a fundamen-tal architectural, choice. Thus if you want to use EJB, you can within a consistent architecture; however, you do not need to make EJB the cornerstone of your architecture. This Spring feature can make devel-oping EJB applications significantly faster, because there is no need to write custom code in service loca-tors or business delegates. Testing EJB client code is also much easier, because it only depends on the EJB’s Business Methods interface (which is not EJB-specific), not on JNDI or the EJB API.Spring also provides support for implementing EJBs, in the form of convenience superclasses for EJB implementation classes, which load a Spring lightweight container based on an environment variable specified in the ejb-jar.xml deployment descriptor. This is a powerful and convenient way of imple-menting SLSBs or MDBs that are facades for fine-grained POJOs: a best practice if you do choose to implement an EJB application. Using this Spring feature does not conflict with EJB in any way—it merely simplifies following good practice.Introducing the Spring FrameworkThe main aim of Spring is to make J2EE easier to use and promote good programming practice. It does not reinvent the wheel; thus you’ll find no logging packages in Spring, no connection pools, no distributed transaction coordinator. All these features are provided by other open source projects—such as Jakarta Commons Logging (which Spring uses for all its log output), Jakarta Commons DBCP (which can be used as local DataSource), and ObjectWeb JOTM (which can be used as transaction manager)—or by your J2EE application server. For the same reason, Spring doesn’t provide an O/R mapping layer: There are good solutions for this problem area, such as Hibernate and JDO.Spring does aim to make existing technologies easier to use. For example, although Spring is not in the business of low-level transaction coordination, it does provide an abstraction layer over JTA or any other transaction strategy. Spring is alsopopular as middle tier infrastructure for Hibernate, because it provides solutions to many common issues like SessionFactory setup, ThreadLocal sessions, and exception handling. With the Spring HibernateTemplate class, implementation methods of Hibernate DAOs can be reduced to one-liners while properly participating in transactions.The Spring Framework does not aim to replace J2EE middle tier services as a whole. It is an application framework that makes accessing low-level J2EE container ser-vices easier. Furthermore, it offers lightweight alternatives for certain J2EE services in some scenarios, such as a JDBC-based transaction strategy instead of JTA when just working with a single database. Essentially, Spring enables you to write appli-cations that scale down as well as up.Spring for Web ApplicationsA typical usage of Spring in a J2EE environment is to serve as backbone for the logical middle tier of a J2EE web application. Spring provides a web application context concept, a powerful lightweight IoC container that seamlessly adapts to a web environment: It can be accessed from any kind of web tier, whether Struts, WebWork, Tapestry, JSF, Spring web MVC, or a custom solution.The following code shows a typical example of such a web application context. In a typical Spring web app, an applicationContext.xml file will reside in theWEB-INF directory, containing bean defini-tions according to the “spring-beans”DTD. In such a bean definition XML file, business objects and resources are defined, for example, a “myDataSource”bean, a “myInventoryManager”bean, and a “myProductManager”bean. Spring takes care of their configuration, their wiring up, and their lifecycle.<beans><bean id=”myDataSource”class=”org.springframework.jdbc. datasource.DriverManagerDataSource”><property name=”driverClassName”> <value>com.mysql.jdbc.Driver</value></property> <property name=”url”><value>jdbc:mysql:myds</value></property></bean><bean id=”myInventoryManager”class=”ebusiness.DefaultInventoryManager”> <property name=”dataSource”><ref bean=”myDataSource”/> </property></bean><bean id=”myProductManager”class=”ebusiness.DefaultProductManager”><property name=”inventoryManager”><ref bean=”myInventoryManager”/> </property><property name=”retrieveCurrentStock”> <value>true</value></property></bean></beans>By default, all such beans have “singleton”scope: one instance per context. The “myInventoryManager”bean will automatically be wired up with the defined DataSource, while “myProductManager”will in turn receive a reference to the “myInventoryManager”bean. Those objects (traditionally called “beans”in Spring terminology) need to expose only the corresponding bean properties or constructor arguments (as you’ll see later in this chapter); they do not have to perform any custom lookups.A root web application context will be loaded by a ContextLoaderListener that is defined in web.xml as follows:<web-app><listener> <listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener>...</web-app>After initialization of the web app, the root web application context will beavailable as a ServletContext attribute to the whole web application, in the usual manner. It can be retrieved from there easily via fetching the corresponding attribute, or via a convenience method in org.springframework.web.context.support.WebApplicationContextUtils. This means that the application context will be available in any web resource with access to the ServletContext, like a Servlet, Filter, JSP, or Struts Action, as follows:WebApplicationContext wac = WebApplicationContextUtils.getWebApplicationContext(servletContext);The Spring web MVC framework allows web controllers to be defined as JavaBeans in child application contexts, one per dispatcher servlet. Such controllers can express dependencies on beans in the root application context via simple bean references. Therefore, typical Spring web MVC applications never need to perform a manual lookup of an application context or bean factory, or do any other form of lookup.Neither do other client objects that are managed by an application context themselves: They can receive collaborating objects as bean references.The Core Bean FactoryIn the previous section, we have seen a typical usage of the Spring IoC container in a web environment: The provided convenience classes allow for seamless integration without having to worry about low-level container details. Nevertheless, it does help to look at the inner workings to understand how Spring manages the container. Therefore, we will now look at the Spring bean container in more detail, starting at the lowest building block: the bean factory. Later, we’ll continue with resource setup and details on the application context concept.One of the main incentives for a lightweight container is to dispense with the multitude of custom facto-ries and singletons often found in J2EE applications. The Spring bean factory provides one consistent way to set up any number of application objects, whether coarse-grained components or fine-grained busi-ness objects. Applying reflection and Dependency Injection, the bean factory can host components that do not need to be aware of Spring at all. Hence we call Spring a non-invasiveapplication framework.Fundamental InterfacesThe fundamental lightweight container interface isorg.springframework.beans.factory.Bean Factory. This is a simple interface, which is easy to implement directly in the unlikely case that none of the implementations provided with Spring suffices. The BeanFactory interface offers two getBean() methods for looking up bean instances by String name, with the option to check for a required type (and throw an exception if there is a type mismatch).public interface BeanFactory {Object getBean(String name) throws BeansException;Object getBean(String name, Class requiredType) throws BeansException;boolean containsBean(String name);boolean isSingleton(String name) throws NoSuchBeanDefinitionException;String[] getAliases(String name) throws NoSuchBeanDefinitionException;}The isSingleton() method allows calling code to check whether the specified name represents a sin-gleton or prototype bean definition. In the case of a singleton bean, all calls to the getBean() method will return the same object instance. In the case of a prototype bean, each call to getBean() returns an inde-pendent object instance, configured identically.The getAliases() method will return alias names defined for the given bean name, if any. This mecha-nism is used to provide more descriptive alternative names for beans than are permitted in certain bean factory storage representations, such as XML id attributes.The methods in most BeanFactory implementations are aware of a hierarchy that the implementation may be part of. If a bean is not found in the current factory, the parent factory will be asked, up until the root factory. From the point of view of a caller, all factories in such a hierarchy will appear to be merged into one. Bean definitions in ancestor contexts are visible to descendant contexts, but not the reverse.All exceptions thrown by the BeanFactory interface and sub-interfaces extend org.springframework. beans.BeansException, and are unchecked. This reflects the fact that low-level configuration prob-lems are not usually recoverable: Hence, application developers can choose to write code to recover from such failures if they wish to, but should not be forced to write code in the majority of cases where config-uration failure is fatal.Most implementations of the BeanFactory interface do not merely provide a registry of objects by name; they provide rich support for configuring those objects using IoC. For example, they manage dependen-cies between managed objects, as well as simple properties. In the next section, we’ll look at how such configuration can be expressed in a simple and intuitive XML structure.The sub-interface org.springframework.beans.factory.ListableBeanFactory supports listing beans in a factory. It provides methods to retrieve the number of beans defined, the names of all beans, and the names of beans that are instances of a given type:public interface ListableBeanFactory extends BeanFactory {int getBeanDefinitionCount();String[] getBeanDefinitionNames();String[] getBeanDefinitionNames(Class type);boolean containsBeanDefinition(String name);Map getBeansOfType(Class type, boolean includePrototypes,boolean includeFactoryBeans) throws BeansException}The ability to obtain such information about the objects managed by a ListableBeanFactory can be used to implement objects that work with a set of other objects known only at runtime.In contrast to the BeanFactory interface, the methods in ListableBeanFactory apply to the current factory instance and do not take account of a hierarchy that the factory may be part of. The org.spring framework.beans.factory.BeanFactoryUtils class provides analogous methods that traverse an entire factory hierarchy.There are various ways to leverage a Spring bean factory, ranging from simple bean configuration to J2EE resource integration and AOP proxy generation. The bean factory is the central, consistent way of setting up any kind of application objects in Spring, whether DAOs, business objects, or web controllers. Note that application objects seldom need to work with the BeanFactory interface directly, but are usu-ally configured and wired by a factory without the need for any Spring-specific code.For standalone usage, the Spring distribution provides a tiny spring-core.jar file that can be embed-ded in any kind of application. Its only third-party dependency beyond J2SE 1.3 (plus JAXP for XML parsing) is the Jakarta Commons Logging API.The bean factory is the core of Spring and the foundation for many other services that the framework offers. Nevertheless, the bean factory can easily be usedstan-dalone if no other Spring services are required.附录2 中文译文Spring框架介绍Spring框架：这是一个流行的开源应用框架，它可以解决很多问题。

毕业论文外文翻译格式

毕业论文外文翻译格式毕业论文外文翻译格式在撰写毕业论文时，外文翻译是一个重要的环节。

无论是引用外文文献还是翻译相关内容，都需要遵循一定的格式和规范。

本文将介绍一些常见的外文翻译格式，并探讨其重要性和应用。

首先，对于引用外文文献的格式，最常见的是使用APA（American Psychological Association）格式。

这种格式要求在引用外文文献时，先列出作者的姓氏和名字的首字母，然后是出版年份、文章标题、期刊名称、卷号和页码。

例如：Smith, J. D. (2010). The impact of climate change on biodiversity. Environmental Science, 15(2), 145-156.在翻译外文文献时，需要注意保持原文的准确性和完整性。

尽量避免意译或添加自己的解释，以免歪曲原文的意思。

同时，还需要在翻译后的文献后面加上“译者”和“翻译日期”的信息，以便读者可以追溯翻译的来源和时间。

其次，对于翻译相关内容的格式，可以参考国际标准组织ISO（International Organization for Standardization）的格式。

这种格式要求在翻译相关内容时，先列出原文，然后是翻译后的文本。

例如：原文：The importance of effective communication in the workplace cannot be overstated.翻译：工作场所有效沟通的重要性不容忽视。

在翻译相关内容时，需要注意保持原文的意思和语气。

尽量使用准确的词汇和语法结构，以便读者能够理解和接受翻译后的内容。

同时，还需要在翻译后的文本后面加上“翻译者”和“翻译日期”的信息，以便读者可以追溯翻译的来源和时间。

此外，对于长篇外文文献的翻译，可以考虑将其分成若干章节，并在每个章节前面加上章节标题。

这样可以使读者更容易理解和阅读翻译后的内容。

Spring和MyBatis整合自动生成代码里面text类型遇到的坑

Spring和MyBatis整合⾃动⽣成代码⾥⾯text类型遇到的坑Spring和MyBatis整合以后，使⽤⾃动⽣成代码⼯具⽣成dao和mapper配置⽂件，⽣成步骤如下（以Intelli idea为例）。

1.编写⽣成代码配置⽂件generatorConfig.xml。

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE generatorConfigurationPUBLIC "-////DTD MyBatis Generator Configuration 1.0//EN""/dtd/mybatis-generator-config_1_0.dtd"><generatorConfiguration><classPathEntry location="D:\dev\maven\repository\mysql\mysql-connector-java\5.1.39\mysql-connector-java-5.1.39.jar"/><context id="DB2Tables" defaultModelType="flat" targetRuntime="MyBatis3"><commentGenerator><property name="suppressDate" value="true"/><property name="suppressAllComments" value="false"/></commentGenerator><jdbcConnection driverClass="com.mysql.jdbc.Driver"connectionURL="jdbc:mysql://localhost:3306/mycollege?characterEncoding=utf-8"userId="root"password="root"></jdbcConnection><javaTypeResolver><property name="forceBigDecimals" value="false"/></javaTypeResolver><javaModelGenerator targetPackage="com.cx.elearnning.model"targetProject="src/main/java"><property name="enableSubPackages" value="true"/><property name="trimStrings" value="true"/></javaModelGenerator><sqlMapGenerator targetPackage="/"targetProject="src/main/resources/mapper"><property name="enableSubPackages" value="true"/></sqlMapGenerator><javaClientGenerator type="XMLMAPPER" targetPackage="com.cx.elearnning.dao"targetProject="src/main/java"><property name="enableSubPackages" value="true"/></javaClientGenerator><table tableName="sys_user" domainObjectName="SysUser"></table></context></generatorConfiguration>2.配置如下maven运⾏命令。

参考文献中文的英文对照

参考文献中文的英文对照在学术论文中，参考文献是非常重要的一部分，它可以为论文的可信度和学术性增添分数，其中包括中文和英文文献。

以下是一些常见的参考文献中文和英文对照：1. 书籍 Book中文：王小明. 计算机网络技术. 北京：清华大学出版社，2018.英文：Wang, X. Computer Network Technology. Beijing: Tsinghua University Press, 2018.2. 学术期刊 Article in Academic Journal中文：张婷婷，李伟. 基于深度学习的影像分割方法. 计算机科学与探索，2019，13(1)：61-67.英文：Zhang, T. T., Li, W. Image Segmentation Method Based on Deep Learning. Computer Science and Exploration, 2019, 13(1): 61-67.3. 会议论文 Conference Paper中文：王维，李丽. 基于云计算的智慧物流管理系统设计. 2019年国际物流与采购会议论文集，2019：112-117.英文：Wang, W., Li, L. Design of Smart Logistics Management System Based on Cloud Computing. Proceedings of the 2019 International Conference on Logistics and Procurement, 2019: 112-117.4. 学位论文 Thesis/Dissertation中文：李晓华. 基于模糊神经网络的水质评价模型研究. 博士学位论文，长春：吉林大学，2018.英文：Li, X. H. Research on Water Quality Evaluation Model Based on Fuzzy Neural Network. Doctoral Dissertation, Changchun: Jilin University, 2018.5. 报告 Report中文：国家统计局. 2019年国民经济和社会发展统计公报. 北京：中国统计出版社，2019.英文：National Bureau of Statistics. Statistical Communique of the People's Republic of China on the 2019 National Economic and Social Development. Beijing: China Statistics Press, 2019.以上是一些常见的参考文献中文和英文对照，希望对大家写作有所帮助。

3-外文翻译模板格式及要求

杭州电子科技大学毕业论文外文文献翻译要求根据《普通高等学校本科毕业设计（论文）指导》的内容，特对外文文献翻译提出以下要求：一、翻译的外文文献可以是一篇，也可以是两篇，但总字符要求不少于1.5万（或翻译成中文后至少在3000字以上）。

二、翻译的外文文献应主要选自学术期刊、学术会议的文章、有关著作及其他相关材料，文献作者最好为国外的专家或学者；应与毕业论文（设计）主题相关，并作为外文参考文献列入毕业论文（设计）的参考文献。

并在每篇中文译文首页用“脚注”形式注明原文作者及出处，中文译文后应附外文原文。

脚注的方法：插入----引用---脚注和尾注三、中文译文的基本撰写格式为：1.题目:采用小三号、黑体字、居中打印，段前段后1行间距；；2.正文:采用小四号、宋体字，行间距为固定值20磅，标准字符间距。

页边距为左3cm，右2.5cm，上下各2.5cm，页面统一采用A4纸。

英文原文如为word文档，请用罗马字体排版，段前空两格，段间距20磅。

页眉为“杭州电子科技大学本科毕业论文外文翻译”，5号宋体字从正文开始编写页码，页码居中。

四、封面格式由学校统一制作（注：封面上的“翻译题目”指中文译文的题目），填充内容为加粗小三号楷体_GB2312，并按“封面、译文一、外文原文一、译文二、外文原文二、考核表”的顺序统一装订。

五、忌自行更改表格样式，学号请写完整。

封面和考核表均为一页纸张，勿换行换页。

注意：1.除了封面和考核表之外，外文翻译有页眉和页码。

2.外文翻译中各级标题统一为段前空两格；若标题无序号，也可按与原文一致的原则处理。

题目段前段后1行一级标题小四宋体加黑，段前段后0.5行其他各级标题段前空两格，小四宋体不加黑，其他与正文要求一致。

毕业论文外文文献翻译毕业设计（论文）题目Xxx（单击此处添加论文题目）翻译（1）题目指翻译后的第一篇中文译文的题目翻译（2）题目指翻译后的第二篇中文译文的题目若无，则本栏留空学院经贸学院专业国际经济与贸易（单击此处添加专业）姓名XXXXXX（单击此处添加姓名）班级XX020811（单击此处添加班级）学号XX023101（单击此处添加班级）指导教师XXXXXX（单击此处添加指导教师）单击此处添加翻译后的第一篇中文译文的题目1 [单击此处添加译文正文]一、单击此处添加一级标题1[单击此处添加译文正文]1.[单击此处添加译文正文]2.[单击此处添加译文正文]3.[单击此处添加译文正文]二、单击此处添加一级标题2[单击此处添加译文正文]1.[单击此处添加译文正文]2.[单击此处添加译文正文]3.[单击此处添加译文正文]三、单击此处添加一级标题3……………………………以下是模板的使用方法说明文字，正式成文后请删除。

关于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. ”(风格乃是思想的衣服,而穿着好的思想就像一个穿着好的人一样,可以显得大为生色) ①这足以说明风格的重要。

毕业设计(论文)外文资料翻译(学生用)

毕业设计外文资料翻译学院：信息科学与工程学院专业：软件工程姓名： XXXXX学号： XXXXXXXXX外文出处： Think In Java (用外文写)附件： 1.外文资料翻译译文；2.外文原文。

附件1：外文资料翻译译文网络编程历史上的网络编程都倾向于困难、复杂，而且极易出错。

程序员必须掌握与网络有关的大量细节，有时甚至要对硬件有深刻的认识。

一般地，我们需要理解连网协议中不同的“层”（Layer）。

而且对于每个连网库，一般都包含了数量众多的函数，分别涉及信息块的连接、打包和拆包；这些块的来回运输；以及握手等等。

这是一项令人痛苦的工作。

但是，连网本身的概念并不是很难。

我们想获得位于其他地方某台机器上的信息，并把它们移到这儿；或者相反。

这与读写文件非常相似，只是文件存在于远程机器上，而且远程机器有权决定如何处理我们请求或者发送的数据。

Java最出色的一个地方就是它的“无痛苦连网”概念。

有关连网的基层细节已被尽可能地提取出去，并隐藏在JVM以及Java的本机安装系统里进行控制。

我们使用的编程模型是一个文件的模型；事实上，网络连接（一个“套接字”）已被封装到系统对象里，所以可象对其他数据流那样采用同样的方法调用。

除此以外，在我们处理另一个连网问题——同时控制多个网络连接——的时候，Java内建的多线程机制也是十分方便的。

本章将用一系列易懂的例子解释Java的连网支持。

15.1 机器的标识当然，为了分辨来自别处的一台机器，以及为了保证自己连接的是希望的那台机器，必须有一种机制能独一无二地标识出网络内的每台机器。

早期网络只解决了如何在本地网络环境中为机器提供唯一的名字。

但Java面向的是整个因特网，这要求用一种机制对来自世界各地的机器进行标识。

为达到这个目的，我们采用了IP（互联网地址）的概念。

IP以两种形式存在着：(1) 大家最熟悉的DNS（域名服务）形式。

我自己的域名是。

所以假定我在自己的域内有一台名为Opus的计算机，它的域名就可以是。

外文翻译格式

外文翻译格式
外语翻译通常需要遵循一定的格式，以确保翻译内容的准确性和易读性。

以下是一个700字外文翻译的通用格式示例：
1. 标题：翻译的内容的标题，通常与原文标题保持一致，居中显示。

2. 原文：原文内容，可将原文段落编号，并保留原文格式，如段落缩进或列表。

3. 译文：相关段落的翻译内容，与原文一一对应，并保持相同的段落编号和格式。

4. 术语翻译：将翻译中使用的特定术语或固定表达进行解释和翻译，避免出现歧义。

5. 校对与审校：对翻译内容进行校对和审校，确保翻译准确无误。

6. 结论：对整个翻译内容进行总结和评价，提出自己的观点和见解。

7. 参考文献：如有需要，列出翻译过程中所参考的文献或资料。

8. 附录：如有需要，可在翻译后添加附录，补充相关资料或说明。

注意事项：
- 翻译应遵循专业的术语和语法规范，尽量保持翻译内容的准确性。

- 可根据需要调整段落的分配和序号，以符合原文和翻译内容的逻辑结构。

- 保持翻译格式的统一和美观，使用合适的字体和字号，并注意标点符号的使用。

- 翻译结束后，应进行校对和审校，以确保翻译质量的准确性和流畅性。

总之，一个700字外文翻译的格式应该清晰明了，结构合理，准确无误，并能为读者提供一个清晰且易于理解的翻译内容。

SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis)

SSM三大框架整合详细教程（Spring+SpringMVC+MyBatis）使用SSM（Spring、SpringMVC和Mybatis）已经有三个多月了，项目在技术上已经没有什么难点了，基于现有的技术就可以实现想要的功能，当然肯定有很多可以改进的地方。

之前没有记录SSM整合的过程，这次刚刚好基于自己的一个小项目重新搭建了一次，而且比项目搭建的要更好一些。

以前解决问题的过程和方法并没有及时记录，以后在自己的小项目中遇到我再整理分享一下。

这次，先说说三大框架整合过程。

个人认为使用框架并不是很难，关键要理解其思想，这对于我们提高编程水平很有帮助。

不过，如果用都不会，谈思想就变成纸上谈兵了！！！先技术，再思想。

实践出真知。

（可通过图片水印查看博客地址）1、基本概念1.1、SpringSpring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。

它是为了解决企业应用开发的复杂性而创建的。

Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。

然而，Spring的用途不仅限于服务器端的开发。

从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

1.2、SpringMVCSpring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。

Spring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。

1.3、MyBatisMyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。

mybatis与spring的整合配置说明

mybatis是ibatis的升级版，spring也有自带mybatis的orm。

所以，搭建ibatis的框架也会有多种方式（我这里mybatis是3.0的，ibatis是2.3的，spring是3.0的，数据库是mysql）。

下面介绍3中方式1，只是用mybatis3。

2，使用mybatis3+spring3(使用mybatis的SqlSessionFactory )。

3，使用ibatis2.3+spring(使用spring自带的ibatis)spring的orm包中只有ibatis，没有mybatis。

而mybatis和ibatis还是有些区别的，比如配置文件属性不同。

第一种方式(只使用mybatis)：1）jar包：cglib-2.2.jarasm-3.1.jarmysql-connector-java-3.1.13.jarmybatis-3.0.5.jarjunit.jar2）mybatis配置文件：[html]view plaincopy1.<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE configuration PUBLIC "-//my//DTD Config 3.0//EN" "/dtd/mybatis-3-config.dtd">2.<configuration>3.4.<settings>5.6.<setting name="cacheEnabled"value="true"/>7.<!-- 全局启用或禁用延迟加载。

当禁用时，所有关联对象都会即时加载 -->8.<setting name="lazyLoadingEnabled"value="true"/>9.<!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。

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和至少一个数据映射器类。

Spring事务管理及与mybatis整合的事务管理

数据访问事务处理in Spring+Mybatis3.0事务---保证了用户的每一次操作都是可靠的，即使出现了异常的访问，也不至于破坏后台数据的完整性;Java事务简介事务必须符合ISO/IEC所定制的ACID原则1)A(atomicity):原子性在事务执行的过程中,任何的失败就将导致事务的任何修改失效,2)C(consistency):一致性事务回滚时,事务所执行的内容必须恢复到初始状态,即事务执行前的状态3)I(isolation):隔离性事务执行过程中对数据的修改,在提交之前的数据对其他事务不可见4)D(durability):持久性已经提交的数据在事务执行失败时,数据的状态都是正确的.事务分类:全局事务(分布式事务):由应用服务器来管理(如JTA),同时可以用于多个事务性的资源;本地事务本地事务和资源相关,主要通过JDBC来实现在实际应用中,存在一种容器管理事务,容器事务主要是由javaEE应用服务器提供,容器事务大多给予JTA完成,事实上这是在容器中覆盖了JDBC和JTA事务.事务特性分析(use spring)TransactionDefinition 接口来定义事务属性。

Code:public interface TransactionDefinition{int getIsolationLevel();int getPropagationBehavior();int getTimeout();boolean isReadOnly();}事务机制a)事务隔离级别隔离级别是指若干个并发的事务之间的隔离程度。

TransactionDefinition 接口中定义了五个表示隔离级别的常量：TransactionDefinition.ISOLATION_DEFAULT(默认值)：表示使用底层数据库的默认隔离级别。

对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。

软件工程专业外文翻译

软件工程专业外文翻译英文原文SSH is Spring + struts + Hibernate an integration framework, is one of the more popular a Web application framework・SpringLight weight 一一from two aspects in terms of size and cost of the Spring are lightweight・A complete Spring framework can in one size only1MB multiple JAR files released .And Spring required processing overhead is not worth mentioning・Inversion of control 一一Spring through a known as inversion of control (IoC) technology promotes loose coupling .When using IoC, an object depend on other objects will be passed in through passive way, but not the object of its own to create or find a dependent object .You can think of IoC and JNDI instead 一一not the object from the container for dependent, but in different container object is initialized object request on own initiative will rely on to it.Aspect oriented programming 一一Spring provides rich support, allowed by separating the application's business logic and system level service cohesiondevelopment .Application object only realize they should do 一一complete business logic・ They are not responsible for other system level concerns.Container 一一Spring contains and management application object configuration and life cycle, in this sense, it is a kind of container, you can configure each of your bean to be created 一一Based on a reconfigurable prototype (prototype), your bean can create a single instance or every time when they are needed to generate a new examples 一一and how they are interrelated・ However, Spring should not be confused with the traditional heavyweight EJB container, they are often large and unwieldy, difficult to use・ StrutsStruts on Model, View and Controller are provided with the corresponding components・ActionServlet, this is Struts core controller, responsible for intercepting the request from the user・Action, this class is typically provided by the user, the controller receives from the ActionServlet request, and according to the request tocall the model business logic method to processing the request, and the results will be returned to the JSP page display.54Part ModelBy ActionForm and JavaBean, where ActionForm used to package the user the request parameters, packaged into a ActionForm object, the object to be forwarded to the Action ActionServlet Action ActionFrom, according to which the request parameters processing a user request・JavaBean encapsulates the underlying business logic, including database access・ Part ViewThis section is implemented by JSP・Struts provides a rich library of tags, tag library can be reduced through the use of the script, a custom tag library can be achieved with Model effective interaction, and increased practical function.The Controller componentThe Controller component is composed of two parts 一一the core of the system controller, the business logic controller・System core controller, the corresponding ActionServlet.The controller is provided with the Struts framework, HttpServlet class inheritance, so it can be configured to mark Servlet .The controller is responsible for all HTTP requests, and then according to the user request to decide whether or not to transfer to business logic controller・ Business logic controller, responsible for processing a user request, itself does not have the processing power, it calls the Model to complete the dea1. The corresponding Action part・HibernateHibernate is an open source object relation mapping framework, it had a very lightweight JDBC object package, makes Java programmers can usearbitrary objects to manipulate database programming thinking .Hibernate can be applied in any use of JDBC occasions, can be in the Java client programto use, also can be in Servlet / JSP Web applications, the most revolutionary, Hibernate can be applied in theEJB J2EE schema to replace CMP, complete data persistence.The core of Hibernate interface has a total of 5, are： Session, SessionFactory, Query, Transaction and Configuration. The 5 core interface in any development will be used in. Through these interfaces, not only can the persistent object access, but also to carry out a transaction control.55中文翻译SSH为spring+ struts+ hibernate的一个集成框架，是忖前较流行的一种Web应用程序开源框架。

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相关的外文文献，并归纳了研究进展和主要成果。

Spring-data-jpa和mybatis的比较及两者的优缺点？

Spring-data-jpa和mybatis的⽐较及两者的优缺点？1. spring data jpa实现了jpa（java persistence api）功能，即可以实现pojo转换为关系型数据库记录的功能，通俗来讲就是可以不写任何的建表sql语句了。

jpa是spring data jpa功能的⼀个⼦集。

⽽mybatis并没有jpa功能，建表语句还是要⾃⼰写的。

2. spring data jpa是全⾃动框架，不需要写任何sql。

⽽mybatis是半⾃动框架，需要⾃⼰写sql，mybatis-plus为mybatis赋能，使其也可以基本上不需要写任何模板sql。

3. debug模式下看⽣成的sql，mybatis下的sql可读性很好，⽽spring data jpa下的查询sql可读性并不好。

如spring data jpa的findOne(id)⽅法，执⾏的sql如下，看起来很奇怪，不是很直接。

4. spring data jpa的insert与update都调⽤同⼀个⽅法save，如果带有主键id（如果启⽤了乐观锁，那么还有version字段），那么就是更新，否则就是新增，所以addOrUpdate是⼀个接⼝，⽽mybatis中提供insert⽅法和updateById⽅法。

由于spring data jpa调⽤同⼀个⽅法，所以其要执⾏两条sql，先执⾏查询，再执⾏插⼊/更新。

另外就是返回值，spring data jpa的返回值是Employee对象，⽽mybatis的返回值是影响的⾏数，当然mybatis也可以得到新增后的id，返回新增后的对象5. spring data jpa的dynamic sql是使⽤JpaSpecificationExecutor，⽽mybatis中是使⽤xml来构造dynamic sql。

当我执⾏分页查询的时候，spring data jpa实际上是调⽤了两个sql语句通过count获得总记录数，即当⽤到Pageable的时候会执⾏⼀条count语句，这可能是很昂贵的操作，因为count操作在innodb中要扫描所有的叶⼦节点通过limit来获得分页记录mybatis获得总记录数好像并不是通过执⾏count语句来获得的，可能是通过游标cursor的⽅式来获得的，通过druid监控，其只执⾏⼀条sql语句6. spring data jpa⽀持⾃⼰来写sql语句，有两种⽅式：1）@Query或@Modifying配合@Query2）通过entityManager但要注意的是：如果⾃⼰写sql语句，那么有些拦截器可能并不能起作⽤，如@PreUpdate相对来说，mybatis就⽐较简单，直接在mapper xml中写sql就可以了ORM框架使⽤中的常见需求1. 后管系统做查询的时候，多个条件通过⼀个接⼝进⾏查询，带了哪个字段就加⼀段sql过滤，通过mybatis如何实现？通过mybatis的dynamic sql是可以实现的，类似getEmpsByCondition，携带了哪个字段，查询条件就带上这个字段的值似乎只能通过写mapper xml来做逻辑判断spring data jpa是通过多个Predicate构造Specification创建where条件的，都是通过代码来控制逻辑的2⾃动设置创建时间/更新时间mybatis 也是使⽤metaObjectHandler来做？还是通过拦截器来做？还是只创建这两个字段，通过数据库语句来控制？spring data jpa中有entityListener，可以不操作数据库，来实现此功能3.字段⾃动加解密？不知道如何实现⾃动在mybatis中，查询出来之后做混淆处理在spring data jpa中，使⽤entityManager查询出来之后做混淆处理4. 乐观锁功能mybatis-plus提供了optimistic-lock pluginspring data jpa也提供了@version注解来做5. 逻辑删除mybatis-plus逻辑删除是放在DefaultSqlInjector中的spring data jpa要⾃⼰写sql来实现逻辑删除。

org.mybatis.spring.MyBatisSystemException异常及处理

org.mybatis.spring.MyBatisSystemException异常及处理MyBatisSystemException异常测试场景在测试springboot中使⽤MyBatis/通⽤Mapper的⾃定义⽅法时出现此异常。

异常如下:org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.type.TypeException: Could not set parameters for mapping: ParameterMapping{property='name', mode=IN, javaType=class ng.String, jdbcType=null, num at org.mybatis.spring.MyBatisExceptionTranslator.translateExceptionIfPossible(MyBatisExceptionTranslator.java:77)at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:446)at com.sun.proxy.$Proxy59.selectList(Unknown Source)at org.mybatis.spring.SqlSessionTemplate.selectList(SqlSessionTemplate.java:230)at org.apache.ibatis.binding.MapperMethod.executeForMany(MapperMethod.java:139)at org.apache.ibatis.binding.MapperMethod.execute(MapperMethod.java:76)at org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:59)at com.sun.proxy.$Proxy79.findByLikeName2(Unknown Source)at 4(TestOne.java:40)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)at ng.reflect.Method.invoke(Method.java:498)at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)at org.springframework.test.context.junit4.statements.RunBeforeTestExecutionCallbacks.evaluate(RunBeforeTestExecutionCallbacks.java:74)at org.springframework.test.context.junit4.statements.RunAfterTestExecutionCallbacks.evaluate(RunAfterTestExecutionCallbacks.java:84)at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:75)at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:86)at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:84)at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:251)at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:97)at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)at org.junit.runners.ParentRunner.run(ParentRunner.java:363)at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:190)at org.junit.runner.JUnitCore.run(JUnitCore.java:137)at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)Caused by: org.apache.ibatis.type.TypeException: Could not set parameters for mapping: ParameterMapping{property='name', mode=IN, javaType=class ng.String, jdbcType=null, numericScale=null, resultMapId='null', jdbcTypeName='nul at org.apache.ibatis.scripting.defaults.DefaultParameterHandler.setParameters(DefaultParameterHandler.java:89)at org.apache.ibatis.executor.statement.PreparedStatementHandler.parameterize(PreparedStatementHandler.java:93)at org.apache.ibatis.executor.statement.RoutingStatementHandler.parameterize(RoutingStatementHandler.java:64)at org.apache.ibatis.executor.SimpleExecutor.prepareStatement(SimpleExecutor.java:86)at org.apache.ibatis.executor.SimpleExecutor.doQuery(SimpleExecutor.java:62)at org.apache.ibatis.executor.BaseExecutor.queryFromDatabase(BaseExecutor.java:326)at org.apache.ibatis.executor.BaseExecutor.query(BaseExecutor.java:156)at org.apache.ibatis.executor.CachingExecutor.query(CachingExecutor.java:109)at org.apache.ibatis.executor.CachingExecutor.query(CachingExecutor.java:83)at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:148)at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:141)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)at ng.reflect.Method.invoke(Method.java:498)at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:433)... 37 moreCaused by: org.apache.ibatis.type.TypeException: Error setting non null for parameter #1 with JdbcType null . Try setting a different JdbcType for this parameter or a different configuration property. Cause: java.sql.SQLException: Parameter inde at org.apache.ibatis.type.BaseTypeHandler.setParameter(BaseTypeHandler.java:55)at org.apache.ibatis.scripting.defaults.DefaultParameterHandler.setParameters(DefaultParameterHandler.java:87)... 52 moreCaused by: java.sql.SQLException: Parameter index out of range (1 > number of parameters, which is 0).at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:965)at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:898)at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:887)at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:861)at com.mysql.jdbc.PreparedStatement.checkBounds(PreparedStatement.java:3327)at com.mysql.jdbc.PreparedStatement.setInternal(PreparedStatement.java:3312)at com.mysql.jdbc.PreparedStatement.setString(PreparedStatement.java:4027)at com.alibaba.druid.pool.DruidPooledPreparedStatement.setString(DruidPooledPreparedStatement.java:369)at org.apache.ibatis.type.StringTypeHandler.setNonNullParameter(StringTypeHandler.java:31)at org.apache.ibatis.type.StringTypeHandler.setNonNullParameter(StringTypeHandler.java:26)at org.apache.ibatis.type.BaseTypeHandler.setParameter(BaseTypeHandler.java:53)... 53 morespringboot启动器import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import tk.mybatis.spring.annotation.MapperScan;@SpringBootApplication@MapperScan(basePackages = {"com.mapper"})public class MapperTestApplicationStarter {public static void main(String[] args) {SpringApplication.run(MapperTestApplicationStarter.class,args);}}⾃定义SQL查询语句package com.mapper;import er;import org.apache.ibatis.annotations.Param;import org.apache.ibatis.annotations.Select;import mon.Mapper;import java.util.List;public interface UserMapper extends Mapper<User> {@Select("select * from user where name like '%#{name}%' ")List<User> findByLikeName2(@Param("name")String name);}异常分析及解决⽅案：经过仔细检查发现是⾃定义SQL语句时出现错误原SQL语句：public interface UserMapper extends Mapper<User> {@Select("select * from user where name like '%#{name}%' ")List<User> findByLikeName2(@Param("name")String name);}应改为：public interface UserMapper extends Mapper<User> {@Select("select * from user where name like '%‘ #{name} ’%' ")List<User> findByLikeName2(@Param("name")String name);}总结：长时间不写SQL语句，⼀些细节（坑）都不注意了。

SpringData与MyBatis的比较和选择

SpringData与MyBatis的比较和选择在Java开发领域，SpringData和MyBatis都是非常受欢迎的持久化框架。

它们都有自己独特的特点和优势，但也存在一些不同之处。

本文将对这两个框架进行比较，帮助开发者选择适合自己项目需求的框架。

1. 简介SpringData是由Spring框架提供的一个用于简化数据库访问的基础架构。

它整合了现有的持久化框架（如JPA、Hibernate、MyBatis等），为开发者提供了一种统一的方式来操作数据库。

而MyBatis则是一个持久化框架，它通过SQL映射文件将Java对象与数据库表进行映射。

2. 功能特点2.1 SpringDataSpringData提供了一套丰富的API，支持多种数据库访问方式，包括关系型数据库、NoSQL数据库以及搜索引擎。

它具有自动生成SQL语句、分页查询、事务管理等功能，并提供了一些常用查询方法的实现，减少了开发者的工作量。

2.2 MyBatisMyBatis是一个轻量级的持久化框架，它与数据库之间的交互主要通过手写的SQL语句。

MyBatis的主要特点是灵活性和可控性，开发者可以根据需求自由编写SQL，优化查询性能。

此外，MyBatis还支持一级、二级缓存，提高了查询的效率。

3. 使用场景3.1 SpringDataSpringData适用于对数据库操作较为简单的场景，对于增删改查等基本操作，SpringData提供了一些默认实现，可以快速完成开发。

同时，SpringData也支持动态查询、排序、分页等高级查询功能，能够满足大部分常见的需求。

3.2 MyBatisMyBatis适用于对数据库操作较为复杂、SQL定制化要求较高的场景。

由于MyBatis将SQL与Java代码分离，开发者完全可以根据需求优化SQL语句，提高查询效率。

此外，MyBatis的一级、二级缓存也适用于对查询性能有较高要求的场景。

4. 性能比较4.1 SpringData由于SpringData是一个整合了多种持久化框架的库，它的性能往往受到具体框架的影响。

fluentmybatis 简书

fluentmybatis 简书摘要：1.简书介绍2.什么是MyBatis3.FluentMyBatis 的特点4.FluentMyBatis 的优势5.如何使用FluentMyBatis6.总结正文：简书是一个优质的中文写作社区，提供了一个便捷的知识分享平台。

在这里，我们可以找到许多关于编程、技术等方面的优质文章。

今天，我要给大家介绍的是关于MyBatis 的FluentMyBatis。

MyBatis 是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。

MyBatis 避免了几乎所有的JDBC 代码和手动设置参数以及获取结果集。

MyBatis 可以使用简单的XML 或注解进行配置和原生映射，将接口和Java 的POJO（Plain Old Java Objects，普通的Java 对象）映射成数据库中的记录。

FluentMyBatis 是MyBatis 的一个扩展，它通过提供更加简洁、清晰的API，让开发者能够更加方便地编写MyBatis 的SQL 语句。

FluentMyBatis 的特点如下：1.更加简洁的API：FluentMyBatis 提供了更加简洁的API，让开发者能够更加方便地编写SQL 语句。

2.支持Lambda 表达式：FluentMyBatis 支持Lambda 表达式，让开发者能够更加简洁地编写SQL 语句。

3.支持动态SQL：FluentMyBatis 支持动态SQL，可以根据条件动态地生成SQL 语句。

4.更加灵活的映射方式：FluentMyBatis 提供了更加灵活的映射方式，让开发者能够更加方便地定制化SQL 语句。

FluentMyBatis 的优势如下：1.提高开发效率：FluentMyBatis 提供了更加简洁、清晰的API，让开发者能够更加方便地编写MyBatis 的SQL 语句，从而提高开发效率。

2.易于维护：FluentMyBatis 的API 设计更加合理，使得代码更加易于维护。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

本科生毕业设计 (论文)外文翻译原文标题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是非常复杂的问题。

因为公司和组织越来越多，不同类型的通讯设备也越来越多，特别当业务要求应用程序使用web和许多通信设备的时候，网络编程的性能越加重要。

所以在互联网上，在增加负载的数据的同时，我们必须照顾体系结构的问题。

让我们简要讨论到目前为止MVC的研究。

1.1没有MVC在web开发的初始阶段，页面被用来设计html，其中Html是纯文本。

这是第一个在互联网上工作的标记语言。

今天仍然是基于块的所有互联网的编程语言。

用户必须实现与静态页面交互，信息手动写在页面时必须改变。

随着时间增长，语言和页面可以按照用户需求相互作用，页面也会有相应的变化。

1.2 MVC模式一第一个重大变化是由于架构的流行，引入了MVC模式。

这种具有控制演示、业务逻辑和流程的架构是以页面为中心，以Java语言为服务器的页面程序。

逻辑就是在这个模型概念中介绍的。

Java bean和scriptlet、表达式等业务逻辑都是以硬性编码的形式存在的。

页面里的所有代码都是用jsp编写的。

让我们假设，我们想传输基于我们收到数据时的jsp的情况。

图一页面导航MVC-1框架1.3 MVC模式二模型1架构能够解决一些网络和网络编程的问题,但仍有很多东西丢失。

它是集中jsp页面的导航，从而能进一步发展的体系结构的观点。

在这个过程中未来发展是Model 2架构。

这个解决了一起使用Servlet和JSP的问题。

能够服务处理初始请求和部分处理数据。

它设置bean然后结果转发到一个jsp页面。

Servlet决定从列表中显示一个页面到页面。

图二MVC-2框架在这个模型中2架构的JSP页面仅用于演示目的。

业务逻辑已经从页面删除。

这使页面更容易表示并且轻、重量级页面也很容易在互联网上显示。

在这个模型中所有的控制和应用程序逻辑都由Servlet处理。

Servlet是用java 编程语言编写的，所以它也是容易处理的Servlet的一部分。

在这种情况下的服务成为全面完整的应用程序,它已成为应用程序的中心点。

在model 2架构中，Servlet成为所有常见任务的“看门人”。

它提供了诸多公共服务,如身份验证、授权、错误控制和应用程序的循环。

此体系结构解决了大部分的问题。

但仍有许多新的问题出现在这个应用架构。

二应用架构与多个框架在越来越多的网络和互联网领域，应用程序的需求正在增长。

单独的一个框架是不能处理应用程序的体系结构的需求的。

满足潮流要求的应用程序有必要设计一个完整的框架体系结构。

Struts框架设计和web应用程序的前端控制开发有着密不可分的联系。

它为用户提供了各种功能交互的应用程序。

它也遵循MVC 2设计特点。

Spring框架是用来设计处理各种任务的。

Spring的工作是基于互联网的应用程序。

它遵循的原则MVC 2。

同时使用Struts和spring框架在单个应用程序应使用MVC设计主体,这样我们可以提高应用程序的性能。

Struts框架包括三个主要模块,简要描述如下：图三Struts框架第一个是使用块控制，以用来表示完整的模型的一部分。

它包含自定义标记库，为我们编写JSP的特定应用程序提供了国际化资源文件。

第二块是代表控制器。

它是导航的完整应用程序，包含XML配置文件和含标签的导航路径。

第三块是模型。

这部分工作主要是分析业务逻辑,抓取和存储数据到数据库中。

它包含Java bean、Enterprise和数据库。

下图显示了struts框架中的组件工作。

图一struts框架组件Struts中的MVC在Spring框架中，MVC的主要表现在以下三个部分。

控制器，Servlet控制器(部分)；Java服务器页面(视图部件)；应用程序业务逻辑，应用程序的形式(模型)。

Spring组件在Spring里，我们也遵循MVC的原则。

它被设计为基于互联网和桌面的应用程序。

Spring包含三个核心组件。

1，控制器:处理导航逻辑和交互与服务的业务逻辑层2，模型:控制器和视图之间的联系，包含由控制器渲染的视图和其所需的数据3，视图:根据用户请求，呈现从模型中获取数据。

spring MVC核心组件如下。

1.DispatcherServlet:Spring的前端控制器实现。

它是控制器进行交互的第一个请求。

我们也可以说它是一个Servlet的实现。

它控制应用程序的完整流程。

2.控制器:用户创建的组件来处理请求封装导航逻辑代表服务对象的业务逻辑。

3.视图:负责渲染输出。

不同的视图可以在查看设备的基础上，选择不同类型的通信设备和输出结果。

ModelAndView:ModelAndView是spring框架的核心部分。

它实现了应用程序的业务逻辑。

它是由控制器控制。

每当它执行时，都会存储业务逻辑和与之关联的视图。

ViewResolver:根据返回的结果，输出显示收到的ModelAndView。

由逻辑视图名称映射到实际的视图是由它实现的。

这部分标识时实现输出媒体是什么，以及如何显示该媒体。

HandlerMapping:该接口使用DispatcherServlet传入的请求映射到单个控制器。

它标识请求,并调用相应的处理程序提供的服务。

下面的图显示了模型的作用。

在这个dispatcher Servlet应用程序的入口点，Struts部分作为框架，而dispatcher Servlet用于发送请求。

Servlet决定处理程序。

那么它将调用控制器，控制器执行ModelAndView。

图5 序列流应用程序的spring框架三提出的方法这种方法的组合应用为两个框架，struts和spring应用程序开发打下了基础。

序列图的组合应用程序解释如上所述,这是应用程序的主要驱动力。

要想使用这种方法，web应用程序的基本知识是必要的。

我们已经测试了上述概念,找出它优点，上述体系结构的主要优点如下：1.它将提供一个非常简洁的部分之间的行动,行动的形式,控制器,处理data we received from the input.1.3 MVC Model 2 :The model 1 architecture was able to solve some of the problem of the web and internet programming but still there were a lot of things missing from it. It was centered on the navigation of the jsp pages so there was the scope of the further development in the architecture point of view. During this process the next development was the Model 2 architecture. This problem was solved using the Servlet and JSP together. The Servest handles the Initial request and partially process the data. It set up the beans then forward the result to the one of the jsp page. The Servlet decide the one of the page to be displayed from the list of pages.In this Model 2 architecture the JSP Pages were used to Presentation purpose only. The Business logic has been removed from the page. This makes the pages easier to represent and light weight pages which were easy to display on the internet.In this model all Control and application logic were handled by the Servlet. The Servlet was written in the java programming language. So it was also easier to handlethe programming part of the Servlet. In this scenario the Servest becomes the power full for the complete application and It has emerged as the center point for the application.In the model 2 architecture the Servlet becomes the gatekeeper for the all common tasks. It provides the common services like authentication, authorization, error control and follow of the application. This architecture have solved the most of the problems. But still there were many new issues emerged while applying this architecture.II. APPLYING ARCHITECTURE WITH MULTIPLE FRAMEWORKSWeb and Internet is ever growing area and the demands for the applications are growing. A single framework is not capable to handle the architecture of the application. To meet the currents requirement of the applications it’s necessary to design a architecture to implement the frameworks.Struts framework have been designed and developed for the front end control of the web applications. It provides the various features for the applications that interact to the users. It also follows the MVC 2 design features.Spring Framework is the designed to handle the various tasks. The spring work for the desktop and internet based applications also. It follows the principals of the MVC 2. The simultaneous use of the Struts and spring frameworks in the single application with the applying the MVC Design principals so that we can Improve the performance of the applications.Struts Framework consists of three major blocks, Described in brief as follows:First is The View Block which controls the presentation part of the complete model. This contains following JSP files which you write for your specific application Set of JSP custom tag libraries Resource filesfor internationalization.Second Block is representing the Controller. This is for navigation the complete application. This contains XML configuration files; it contains the tags for the navigation of the paths.Third Block is the Model. This part do the work of the Business Logic, Fetching and storing data to the database.This contains following Java Beans Enterprise Java Beans Database. Following figure shows the working of the components in the struts framework.MVC in StrutsThe major three parts of the MVC are as follows in the spring framework. Servlet controller (Controller Part) Java Server Pages or any other presentation technology (View Part) Application Business Logic: in the form of whatever suits the application (Model Part).SpringComponents.In the spring we also follows the principals of the MVC . It has been designed more for the desktop and internet based applications. Spring consist of three core collaborating components. 1. Controller: Handles navigation logic and interacts with the Service tier for business logic 2. Model: The contract between the Controller and the View Contains the data needed to render the View Populated by the Controller 3. View: Renders the response to the request Pulls data from the model.Core components in the spring MVC are as follows.DispatcherServlet: Spring’s Front Controller implemen tation. It is the first controller which interacts to the requests. We can also say it is an implementation of the Servlet. It controls the complete flow of the application.2. Controller: User created component for handling requests encapsulatesnavigation logic delegates to the service objects for business logic.3.View: Responsible for rendering output. Different views can be selected for the different types of output bases on the results and the viewing device, communication devices.4.ModelAndView: ModelAndView is the core part of the spring framework. It implements the business logic of the application. It is controlled by the controller. It stores the business logic and the view associated with it. Whenever it is executed it will the data with the name of the view.5. ViewResolver: How the output is to be displayed depends on the result received from ModelAndView. It is used to map logical view names to actual view implementations. This part identifies and implement what is the output media and how to display it.6. HandlerMapping: Strategy interface used by DispatcherServlet for mapping incoming requests to individual Controllers. It identifies the request and calls the respective handler to provide the services.The following figure shows how the model will work. In this the dispatcher Servlet is the entry point for the application. The Struts parts do it’s work and send the request to the dispatcher Servlet. The Servlet decides the handler. Then it will call to the controller. Controller will execute the ModelAndView.III. PROPOSED METHODOLOGYThis approach is based a combination of applying the two framework struts and spring for the application development. The sequence diagram for the combined application is explained as above, which is the main driving force for the application. This approach assumes that basic knowledge of web applications is essential. We have tested the above concepts and find out it successfully. Major benefits注：1. 指导教师对译文进行评阅时应注意以下几个方面：①翻译的外文文献与毕业设计（论文）的主题是否高度相关，并作为外文参考文献列入毕业设计（论文）的参考文献；②翻译的外文文献字数是否达到规定数量（3 000字以上）；③译文语言是否准确、通顺、具有参考价值。