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字外文翻译的格式应该清晰明了，结构合理，准确无误，并能为读者提供一个清晰且易于理解的翻译内容。

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字以上）；③译文语言是否准确、通顺、具有参考价值。