当前位置：搜档网 › Java技术外文翻译文献

Java技术外文翻译文献

(文档含中英文对照即英文原文和中文翻译)

外文：

Core Java? Volume II–Advanced Features When Java technology first appeared on the scene, the excitement was not about a well-crafted programming language but about the possibility of safely executing applets that are delivered over the Internet (see V olume I, Chapter 10 for more information about applets). Obviously, delivering executable applets is practical only when the recipients are sure that the code can't wreak havoc on their machines. For this reason, security was and is a major concern of both the designers and the users of Java technology. This means that unlike other languages and

systems, where security was implemented as an afterthought or a reaction to break-ins, security mechanisms are an integral part of Java technology.

Three mechanisms help ensure safety:

?Language design features (bounds checking on arrays, no unchecked type conversions, no pointer arithmetic, and so on).

?An access control mechanism that controls what the code can do (such as file access, network access, and so on).

?Code signing, whereby code authors can use standard cryptographic algorithms to authenticate Java code. Then, the users of the code can determine exactly who created the code and whether the code has been altered after it was signed.

Below, you'll see the cryptographic algorithms supplied in the java.security package, which allow for code signing and user authentication.

As we said earlier, applets were what started the craze over the Java platform. In practice, people discovered that although they could write animated applets like the famous "nervous text" applet, applets could not do a whole lot of useful stuff in the JDK 1.0 security model. For example, because applets under JDK 1.0 were so closely supervised, they couldn't do much good on a corporate intranet, even though relatively little risk attaches to executing an applet from your company's secure intranet. It quickly became clear to Sun that for applets to become truly useful, it was important for users to be able to assign different levels of security, depending on where the applet originated. If an applet comes from a trusted supplier and it has not been tampered with, the user of that applet can then decide whether to give the applet more privileges.

To give more trust to an applet, we need to know two things:

?Where did the applet come from?

?Was the code corrupted in transit?

In the past 50 years, mathematicians and computer scientists have developed sophisticated algorithms for ensuring the integrity of data and for electronic signatures. The java.security package contains implementations of many of these algorithms. Fortunately, you don't need to understand the underlying mathematics to use the algorithms in the java.security package. In the next sections, we show you how message digests can detect changes in data files and how digital signatures can prove the identity of the signer.

A message digest is a digital fingerprint of a block of data. For example, the so-called SHA1 (secure hash algorithm #1) condenses any data block, no matter how long, into a sequence of 160 bits (20 bytes). As with real fingerprints, one hopes that no two messages have the same SHA1 fingerprint. Of course, that cannot be true—there are only 2160 SHA1 fingerprints, so there must be some messages with the same fingerprint. But 2160is so large that the probability of duplication occurring is negligible. How negligible? According to James Walsh in True Odds: How Risks Affect Your Everyday Life (Merritt Publishing 1996), the chance that you will die from being struck by lightning is about one in 30,000. Now, think of nine other people, for example, your nine least favorite managers or professors. The chance that you and all of them will die from lightning strikes is higher than that of a forged message having the same SHA1 fingerprint as the original. (Of course, more than ten people, none of whom you are likely to know, will die from lightning strikes. However, we are talking about the far slimmer chance that your particular choice of people will be wiped out.)

A message digest has two essential properties:

?If one bit or several bits of the data are changed, then the message digest also changes.

? A forger who is in possession of a given message cannot construct a fake message that has the same message digest as the original.

The second property is again a matter of probabilities, of course. Consider the following message by the billionaire father:"Upon my death, my property shall be divided equally among my children; however, my son George shall receive nothing."

That message has an SHA1 fingerprint of

2D 8B 35 F3 BF 49 CD B1 94 04 E0 66 21 2B 5E 57 70 49 E1 7E

The distrustful father has deposited the message with one attorney and the fingerprint with another. Now, suppose George can bribe the lawyer holding the message. He wants to change the message so that Bill gets nothing. Of course, that changes the fingerprint to a completely different bit pattern:

2A 33 0B 4B B3 FE CC 1C 9D 5C 01 A7 09 51 0B 49 AC 8F 98 92

Can George find some other wording that matches the fingerprint? If he had been the proud owner of a billion computers from the time the Earth was formed, each computing a million messages a second, he would not yet have found a message he could substitute.

A number of algorithms have been designed to compute these message digests. The two best-known are SHA1, the secure hash algorithm developed by the National Institute of Standards and Technology, and MD5, an algorithm invented by Ronald Rivest of MIT. Both algorithms scramble the bits of a message in ingenious ways. For details about these algorithms, see, for example, Cryptography and Network Security, 4th ed., by William Stallings (Prentice Hall 2005). Note that recently, subtle regularities have been discovered in both algorithms. At this point, most cryptographers recommend avoiding MD5 and using SHA1 until a stronger alternative becomes available.

The Java programming language implements both SHA1 and MD5. The MessageDigest class is a factory for creating objects that encapsulate the fingerprinting algorithms. It has a static method, called getInstance, that returns an object of a class that extends the MessageDigest class. This means the MessageDigest class serves double duty:

?As a factory class

?As the superclass for all message digest algorithms

For example, here is how you obtain an object that can compute SHA fingerprints:

MessageDigest alg = MessageDigest.getInstance("SHA-1");

(To get an object that can compute MD5, use the string "MD5" as the argument to getInstance.)

After you have obtained a MessageDigest object, you feed it all the bytes in the message by repeatedly calling the update method. For example, the following code passes all bytes in a file to the alg object just created to do the fingerprinting：

InputStream in = . . .

int ch;

while ((ch = in.read()) != -1)

alg.update((byte) ch);

Alternatively, if you have the bytes in an array, you can update the entire array at once:

byte[] bytes = . . .;

alg.update(bytes);

When you are done, call the digest method. This method pads the input—as required by the fingerprinting algorithm—does the computation, and returns the digest as an array of bytes.

byte[] hash = alg.digest();

The program in Listing 9-15 computes a message digest, using either SHA or MD5. You can load the data to be digested from a file, or you can type a message in the text area.

Message Signing

In the last section, you saw how to compute a message digest, a fingerprint for the original message. If the message is altered, then the fingerprint of the altered message will not match the fingerprint of the original. If the message and its fingerprint are delivered separately, then the recipient can check whether the message has been tampered with. However, if both the message and the fingerprint were intercepted, it is an easy matter to modify the message and then recompute the fingerprint. After all, the message digest algorithms are publicly known, and they don't require secret keys. In that case, the recipient of the forged message and the recomputed fingerprint would never know that the message has been altered. Digital signatures solve this problem.

To help you understand how digital signatures work, we explain a few concepts from the field called public key cryptography. Public key cryptography is based on the notion of a public key and private key. The idea is that you tell everyone in the world your public key. However, only you hold the private key, and it is important that you safeguard it and don't release it to anyone else. The keys are matched by mathematical relationships, but the exact nature of these relationships is not important for us.

The keys are quite long and complex. For example, here is a matching pair of public and private Digital Signature Algorithm (DSA) keys.

Public key:

Code View:

fca682ce8e12caba26efccf7110e526db078b05edecbcd1eb4a208f3ae1617ae01f35b91a47e6df 63413c5e12ed0899bcd132acd50d99151bdc43ee737592e17

q: 962eddcc369cba8ebb260ee6b6a126d9346e38c5

g:678471b27a9cf44ee91a49c5147db1a9aaf244f05a434d6486931d2d14271b9e35030b71fd7 3da179069b32e2935630e1c2062354d0da20a6c416e50be794ca4

c0b6e67b4ac098eb1a32c5f8c4c1f0e7e6fb9d832532e27d0bdab9ca2d2a8123ce5a8018b8161 a760480fadd040b927281ddb22cb9bc4df596d7de4d1b977d50

Private key:

Code View:

fca682ce8e12caba26efccf7110e526db078b05edecbcd1eb4a208f3ae1617ae01f35b91a47e6df 63413c5e12ed0899bcd132acd50d99151bdc43ee737592e17

q: 962eddcc369cba8ebb260ee6b6a126d9346e38c5

678471b27a9cf44ee91a49c5147db1a9aaf244f05a434d6486931d2d14271b9e35030b71fd73 da179069b32e2935630e1c2062354d0da20a6c416e50be794ca4

x: 146c09f881656cc6c51f27ea6c3a91b85ed1d70a

It is believed to be practically impossible to compute one key from the other. That is, even though everyone knows your public key, they can't compute your private key in your lifetime, no matter how many computing resources they have available.

It might seem difficult to believe that nobody can compute the private key from the public keys, but nobody has ever found an algorithm to do this for the encryption algorithms that are in common use today. If the keys are sufficiently long, brute force—simply trying all possible keys—would require more computers than can be built from all the atoms in the solar system, crunching away for thousands of years. Of course, it is possible that someone could come up with algorithms for computing keys that are much more clever than brute force. For example, the RSA algorithm (the encryption algorithm invented by Rivest, Shamir, and Adleman) depends on the difficulty of factoring large numbers. For the last 20 years, many of the best mathematicians have tried to come up with good factoring algorithms, but so far with no success. For that reason, most cryptographers believe that keys with a "modulus" of 2,000 bits or more are currently completely safe from any attack. DSA is believed to be similarly secure.

Figure 9-12 illustrates how the process works in practice.

Suppose Alice wants to send Bob a message, and Bob wants to know this message came from Alice and not an impostor. Alice writes the message and then signs the message digest with her private key. Bob gets a copy of her public key. Bob then applies the public key to verify the

signature. If the verification passes, then Bob can be assured of two facts:

?The original message has not been altered.

?The message was signed by Alice, the holder of the private key that matches the public key that Bob used for verification.

You can see why security for private keys is all-important. If someone steals Alice's private key or if a government can require her to turn it over, then she is in trouble. The thief or a government agent can impersonate her by sending messages, money transfer instructions, and so on, that others will believe came from Alice.

The X.509 Certificate Format

To take advantage of public key cryptography, the public keys must be distributed. One of the most common distribution formats is called X.509. Certificates in the X.509 format are widely used by VeriSign, Microsoft, Netscape, and many other companies, for signing e-mail messages, authenticating program code, and certifying many other kinds of data. The X.509 standard is part of the X.500 series of recommendations for a directory service by the international telephone standards body, the CCITT.

The precise structure of X.509 certificates is described in a formal notation, called "abstract syntax notation #1" or ASN.1. Figure 9-13 shows the ASN.1 definition of version 3 of the X.509 format. The exact syntax is not important for us, but, as you can see, ASN.1 gives a precise definition of the structure of a certificate file. The basic encoding rules, or BER, and a variation, called distinguished encoding rules (DER) describe precisely how to save this structure in a binary file. That is, BER and DER describe how to encode integers, character strings, bit strings, and constructs such as SEQUENCE, CHOICE, and OPTIONAL.

译文：

Java核心技术卷Ⅱ高级特性

当Java技术刚刚问世时，令人激动的并不是因为它是一个设计完美的编程语言，而是因为它能够安全地运行通过因特网传播的各种applet。很显然，只有当用户确信applet 的代码不会破坏他的计算机时，用户才会接受在网上传播的可执行的applet。正因为如此，无论过去还是现在，安全都是设计人员和Java技术使用者所关心的一个重大问题。这就意味着，Java技术与其他的语言和系统有所不同，在那些语言和系统中安全是事后才想到要去实现的，或者仅仅是对破坏的一种应对措施，而对Java技术来说，安全机制是一个不可分割的组成部分。

Java技术提供了以下三种确保安全的机制：

(1)语言设计特性（对数组的边界进行检查，无不检查类型的转换，无指针算法等）。

(2)访问控制机制，用于控制代码能够执行的功能（比如文件访问，网络访问等）。

(3) 代码签名，利用该特性，代码的作者就能够用标准的加密算法来表明Java代码的身份。这样，该代码的使用者就能够准确地知道谁创建了该代码，以及代码被标识后是否被修改过。

下面，我们要介绍java.security包提供的加密算法，用来进行代码的标识和用户身份认证。

正如我们前面所说，applet 是在Java平台上开始流行起来的。实际上，人们发现尽管他们可以编写像著名的“nervous text”那样栩栩如生的applet，但是在JDK1.0安全模式下无法发挥其一整套非常有用的作用。例如，由于JDK1.0下的applet要受到严密的监督，因此，即使applet在公司安全内部网上运行时的风险相对较小，applet也无法在企业内部网上发挥很大的作用。Sun公司很快就认识到，要使applet真正变得非常有用，用户必须可以根据applet的来源为其分配不同的安全级别。如果applet来自值得信赖的提供商，并且没有被篡改过，那么applet的用户就可以决定是否给applet授予更多的运行特权。

如果要给予applet更多的信赖，你必须知道下面两件事：

(1)applet来自哪里？

(2)在传输过程中代码是否被破坏？

在过去的50年里，数学家和技术机科学家已经开发出各种各样成熟的算法，用于确保数据和电子签名的完整性，在java.security包中包含了许多这些算法的实现。在下面几节，我们将要介绍消息摘要是如何检测数据文件中的变化的，以及数字签名是如何证明签名者的身份的。

消息摘要是数据块的数字指纹。例如，所谓的SHA1（安全散列算法#1）可将任何数据块，无论其数据有多长，都压缩为160位（20字节）的序列。与真实的指纹一样，人们希望任何两条消息都不会有相同的SHA1指纹。当然这是不可能的—因为只存在2160 个SHA1指纹，所有肯定会有某些消息具有相同的指纹。因为2160是一个很大的数字，所以存在重复指纹的可能性微乎其微，那么这种重复的可能性到底小到什么程度呢？根据James Walsh 在他的《True Odds:How Risks Affect Your Everyday Life》,Merritt Publishing出版社1996年出版，一书中所阐述的，你和他们所有的人都死于雷击的概率，比伪造的消息与原来消息具有相同的SHA1指纹的概率还要高。（当然，可能有你不认识的其他10个以上的人会死于雷击，但这里我们讨论的是你选择的特定的人的死亡概率）。

消息摘要具有两个基本属性：

(1)如果数据的1位或者几位改变了，那么消息摘要也将改变。

(2）拥有给定消息的伪造者不能创建与原消息具有相同摘要的假消息。

当然，第二个属性又是一个概率问题。让我们来看看下面这位亿万富翁下的遗嘱：“我死了之后，我的财产将由我的孩子平分，但是，我的儿子George应该拿不到一个子。”

这份遗嘱的SHA1指纹为：

2D 8B 35 F3 BF 49 CD B1 94 04 E0 66 21 2B 5E 57 70 49 E1 7E

这位有疑心病的父亲将这份遗嘱交给一位律师保存，而将指纹交给另一位律师保存。现在，假设George能够贿赂那位保存遗嘱的律师，他想修改这份遗嘱，使得Bill一无所得。当然，这需要将原指纹改为下面这样完全不同的位模式：

2A 33 0B 4B B3 FE CC 1C 9D 5C 01 A7 09 51 0B 49 AC 8F 98 92

那么George能够找到与该指纹相匹配的其他文字吗？如果从地球形成之时，他就很自豪地拥有10亿台计算机，每台计算机每秒钟处理一百万条信息，他依然无法找到一个能够替换的遗嘱。

人们已经设计出大量的算法，用于计算这些消息摘要，其中最著名的两种算法是SHAI 和MD5。SHAI是由美国国家标准和技术学会开发的加密散列算法，MD5是由麻省理工学院的Ronald Rivest发明的算法。这两种算法都使用了独特巧妙的方法对消息中的各个位进

行扰乱。如果要了解这些方法的详细信息，请参阅William Stallings撰写的《Cryptography and Network Security》一书，该书由Prentice Hall出版社于2005年出版口值得注意的是，最近人们在这两种算法中发现了某些微妙的规律性，因此许多密码人员建议最好避免使用MD5，而应该使用SHA1算法，直到有更强的加密算法出现。

Java编程语言已经实现了SHA1和MD5。MessageDigest类是用于创建封装了指纹算法的对象的“工厂”，它的静态方法getInstance返回继承了MessageDigest类的某个类的对象。这意味着MessageDigest类能够承担下面的双重职责：

（1）作为一个工厂类。

（2）作为所有消息摘要算法的超类。

例如，下面是如何获取一个能够计算SHA指纹的对象的方法：

MessageDigest alg = MessageDigest.getI nstance(“SHA-1”)；

（如果要获取计算MD5的对象，请使用字符串“MD5”作为getInstance的参数。）当你已经获取MessageDigest对象之后，通过反复调用update方法，将信息中的所有字节提供给该对象。例如，下面的代码将文件中的所有字节传给上面建立的alg对象，以执行指纹算法：

InputStream in=….

int ch；

while((ch=in.read())!=-1)

alg.updat((byte) ch)；

另外，如果这些字节存放在一个数组中，那就可以一次完成整个数组的更新：

byte[] bytes =．．．；

alg.update(bytes)；

当完成上述操作后，调用digest方法。该方法填充输入信息—指纹算法需要的—并且进行相应的计算，然后以字节数组的形式返回消息摘要。

byte[] hash=alg.digest()；

程序清单9-15中的程序计算了一个消息摘要，既可以用SHA，也可以使用MD5来计算。可以从文件加载需要计算摘要的数据，也可以直接将信息输入文本区域。图9-11显示了该应用程序的画面。

消息签名

在上一节中，我们介绍了如何计算原始消息的消息摘要和指纹的方法。如果消息改变

毕业设计外文翻译资料

外文出处：《Exploiting Software How to Break Code》By Greg Hoglund, Gary McGraw Publisher : Addison Wesley Pub Date : February 17, 2004 ISBN : 0-201-78695-8 译文标题： JDBC接口技术译文： JDBC是一种可用于执行SQL语句的JavaAPI（ApplicationProgrammingInterface应用程序设计接口）。它由一些Java语言编写的类和界面组成。JDBC为数据库应用开发人员、数据库前台工具开发人员提供了一种标准的应用程序设计接口，使开发人员可以用纯Java语言编写完整的数据库应用程序。一、ODBC到JDBC的发展历程说到JDBC，很容易让人联想到另一个十分熟悉的字眼“ODBC”。它们之间有没有联系呢？如果有，那么它们之间又是怎样的关系呢？ ODBC是OpenDatabaseConnectivity的英文简写。它是一种用来在相关或不相关的数据库管理系统（DBMS）中存取数据的，用C语言实现的，标准应用程序数据接口。通过ODBCAPI，应用程序可以存取保存在多种不同数据库管理系统（DBMS）中的数据，而不论每个DBMS使用了何种数据存储格式和编程接口。 1．ODBC的结构模型 ODBC的结构包括四个主要部分：应用程序接口、驱动器管理器、数据库驱动器和数据源。应用程序接口：屏蔽不同的ODBC数据库驱动器之间函数调用的差别，为用户提供统一的SQL编程接口。驱动器管理器：为应用程序装载数据库驱动器。数据库驱动器：实现ODBC的函数调用，提供对特定数据源的SQL请求。如果需要，数据库驱动器将修改应用程序的请求，使得请求符合相关的DBMS所支持的文法。数据源：由用户想要存取的数据以及与它相关的操作系统、DBMS和用于访问DBMS的网络平台组成。虽然ODBC驱动器管理器的主要目的是加载数据库驱动器，以便ODBC函数调用，但是数据库驱动器本身也执行ODBC函数调用，并与数据库相互配合。因此当应用系统发出调用与数据源进行连接时，数据库驱动器能管理通信协议。当建立起与数据源的连接时，数据库驱动器便能处理应用系统向DBMS发出的请求，对分析或发自数据源的设计进行必要的翻译，并将结果返回给应用系统。 2．JDBC的诞生自从Java语言于1995年5月正式公布以来，Java风靡全球。出现大量的用java语言编写的程序，其中也包括数据库应用程序。由于没有一个Java语言的API，编程人员不得不在Java程序中加入C语言的ODBC函数调用。这就使很多Java的优秀特性无法充分发挥，比如平台无关性、面向对象特性等。随着越来越多的编程人员对Java语言的日益喜爱，越来越多的公司在Java程序开发上投入的精力日益增加，对java语言接口的访问数据库的API 的要求越来越强烈。也由于ODBC的有其不足之处，比如它并不容易使用，没有面向对象的特性等等，SUN公司决定开发一Java语言为接口的数据库应用程序开发接口。在JDK1．x 版本中，JDBC只是一个可选部件，到了JDK1．1公布时，SQL类包（也就是JDBCAPI）

外文翻译java

外文资料译文及原文 Java Java I/O 系统对编程语言的设计者来说，创建一套好的输入输出(I/O)系统，是一项难度极高的任务。这一点可以从解决方案的数量之多上看出端倪。这个问题难就难在它要面对的可能性太多了。不仅是因为有那么多I/O的源和目地(文件，控制台，网络连接等等)，而且还有很多方法(顺序的『sequential』，随机的『random-access』，缓存的『buffered』，二进制的『binary』，字符方式的『character』，行的『by lines』，字的『by words』，等等)。 Java类库的设计者们用"创建很多类"的办法来解决这个问题。坦率地说Java I/O系统的类实在是太多了，以至于初看起来会把人吓着（但是，具有讽刺意味的是，这种设计实际上是限制了类的爆炸性增长）。此外，Java在1.0版之后又对其I/O类库作了重大的修改，原先是面向byte的，现在又补充了面向Unicode字符的类库。为了提高性能，完善功能，JDK 1.4又加了一个nio(意思是"new I/O"。这个名字会用上很多年)。这么以来，如果你想对Java的I/O 类库有个全面了解，并且做到运用自如，你就得先学习大量的类。此外，了解 I/O类库的演化的历史也是相当重要的。可能你的第一反应是"别拿什么历史来烦我了，告诉我怎么用就可以了！"但问题是，如果你对这段历史一无所知，很快就会被一些有用或是没用的类给搞糊涂了。

本章会介绍Java标准类库中的各种I/O类，及其使用方法。 File 类在介绍直接从流里读写数据的类之前，我们先介绍一下处理文件和目录的类。 File类有一个极具欺骗性的名字；或许你会认为这是一个关于文件的类，但它不是。你可以用它来表示某个文件的名字，也可以用它来表示目录里一组文件的名字。如果它表示的是一组文件，那么你还可以用list( )方法来进行查询，让它会返回String数组。由于元素数量是固定的，因此数组会比容器更好一些。如果你想要获取另一个目录的清单，再建一个File对象就是了。实际上，叫它"FilePath"可能会更好一些。下面我们举例说明怎样使用这个类及其相关的FilenameFilter接口。目录列表器假设你想看看这个目录。有两个办法。一是不带参数调用list( )。它返回的是File对象所含内容的完整清单。但是，如果你要的是一个"限制性列表(restricted list)"的话——比方说，你想看看所有扩展名为.java的文件——那么你就得使用"目录过滤器"了。这是一个专门负责挑选显示File对象的内容的类。下面就是源代码。看看，用了java.utils.Arrays.sort( )和11章的AlphabeticComparator之后，我们没费吹灰之力就对结果作了排序(按字母顺序)： //: c12:DirList.java // Displays directory listing using regular expressions. // {Args: "D.*\.java"} import java.io.*; import java.util.*; import java.util.regex.*; import com.bruceeckel.util.*; public class DirList { public static void main(String[] args) { File path = new File("."); String[] list; if(args.length == 0) list = path.list(); else list = path.list(new DirFilter(args[0])); Arrays.sort(list, new AlphabeticComparator());

软件开发概念和设计方法大学毕业论文外文文献翻译及原文

毕业设计（论文）外文文献翻译文献、资料中文题目：软件开发概念和设计方法文献、资料英文题目：文献、资料来源：文献、资料发表（出版）日期：院（部）：专业：班级：姓名：学号：指导教师：翻译日期： 2017.02.14

外文资料原文 Software Development Concepts and Design Methodologies During the 1960s, ma inframes and higher level programming languages were applied to man y problems including human resource s yste ms,reservation s yste ms, and manufacturing s yste ms. Computers and software were seen as the cure all for man y bu siness issues were some times applied blindly. S yste ms sometimes failed to solve the problem for which the y were designed for man y reasons including: ?Inability to sufficiently understand complex problems ?Not sufficiently taking into account end-u ser needs, the organizational environ ment, and performance tradeoffs ?Inability to accurately estimate development time and operational costs ?Lack of framework for consistent and regular customer communications At this time, the concept of structured programming, top-down design, stepwise refinement，and modularity e merged. Structured programming is still the most dominant approach to software engineering and is still evo lving. These failures led to the concept of "software engineering" based upon the idea that an engineering-like discipl ine could be applied to software design and develop ment. Software design is a process where the software designer applies techniques and principles to produce a conceptual model that de scribes and defines a solution to a problem. In the beginning, this des ign process has not been well structured and the model does not alwa ys accurately represent the problem of software development. However,design methodologies have been evolving to accommo date changes in technolog y coupled with our increased understanding of development processes. Whereas early desig n methods addressed specific aspects of the

JAVA外文文献+翻译

本科毕业设计方案外文翻译范本

I / 11 本科毕业设计外文翻译 <2018届）论文题目基于WEB 的J2EE 的信息系统的方法研究作者姓名[单击此处输入姓名] 指导教师[单击此处输入姓名] 学科(专业 > 所在学院计算机科学与技术学院提交日期[时间 ]

基于WEB的J2EE的信息系统的方法研究摘要：本文介绍基于工程的Java开发框架背后的概念，并介绍它如何用于IT 工程开发。因为有许多相同设计和开发工作在不同的方式下重复，而且并不总是符合最佳实践，所以许多开发框架建立了。我们已经定义了共同关注的问题和应用模式，代表有效解决办法的工具。开发框架提供：<1）从用户界面到数据集成的应用程序开发堆栈；<2）一个架构，基本环境及他们的相关技术，这些技术用来使用其他一些框架。架构定义了一个开发方法，其目的是协助客户开发工程。关键词：J2EE 框架WEB开发一、引言软件工具包用来进行复杂的空间动态系统的非线性分析越来越多地使用基于Web的网络平台，以实现他们的用户界面，科学分析，分布仿真结果和科学家之间的信息交流。对于许多应用系统基于Web访问的非线性分析模拟软件成为一个重要组成部分。网络硬件和软件方面的密集技术变革[1]提供了比过去更多的自由选择机会[2]。因此，WEB平台的合理选择和发展对整个地区的非线性分析及其众多的应用程序具有越来越重要的意义。现阶段的WEB发展的特点是出现了大量的开源框架。框架将Web开发提到一个更高的水平，使基本功能的重复使用成为可能和从而提高了开发的生产力。在某些情况下，开源框架没有提供常见问题的一个解决方案。出于这个原因，开发在开源框架的基础上建立自己的工程发展框架。本文旨在描述是一个基于Java的框架，该框架利用了开源框架并有助于开发基于Web的应用。通过分析现有的开源框架，本文提出了新的架构，基本环境及他们用来提高和利用其他一些框架的相关技术。架构定义了自己开发方法，其目的是协助客户开发和事例工程。应用程序设计应该关注在工程中的重复利用。即使有独特的功能要求，也

JAVA外文文献翻译基于Java技术的Web应用设计模型的比较研究

中文翻译基于Java技术的Web应用设计模型的比较研究来源：School of Computer Science and Engineering University of New South Wales Sydney, NSW 2052, Australia 作者：Budi Kurniawan and Jingling Xue 摘要 Servlet技术是在建立可扩展性Web应用中被应用最广泛的技术。在运用JAVA技术开发Web应用中有四种模型,分别是:Model 1、Model 2、Struts和JavaServer Faces JSF。Model 1使用一连串的JSP页面，Model 2采用了模型，视图，控制器MVC模式。Struts是一个采用了Model 2设计模型的框架，JSF是一种支持ready-to-use组件来进行快速Web应用开发的新技术。Model 1对于中等和大型的应用来说很难维护，所以不推荐使用。本文通过利用Model 2、Struts和JSF这三种模型分别构建三个不同版本的在线商店应用程序来比较和评价这三种模型在应用程序开发和性能上的差异。 1.绪论当今Web应用是一种展现动态内容的最普遍的方式。构建Web应用有许多种方法，其中最流行的是Servlet技术。这种技术的流行是因为它比CGI、PHP等其他技术更具优越性。然而Servlet对于开发来说还是麻烦的，因为它在传送HTML 标签时需要程序员将他们组合成为一个字符串对象，再将这个对象传给浏览器。同样的，对于输出的一个很小的改动也要求Servlet被重新编译。基于这个原因SUN 公司发明了JavaServer Pages JSP技术。JSP允许HTML标签和Java代码混合在

本科毕业设计外文翻译

Section 3 Design philosophy, design method and earth pressures 3.1 Design philosophy 3.1.1 General The design of earth retaining structures requires consideration of the interaction between the ground and the structure. It requires the performance of two sets of calculations: 1）a set of equilibrium calculations to determine the overall proportions and the geometry of the structure necessary to achieve equilibrium under the relevant earth pressures and forces; 2）structural design calculations to determine the size and properties of thestructural sections necessary to resist the bending moments and shear forces determined from the equilibrium calculations. Both sets of calculations are carried out for specific design situations (see 3.2.2) in accordance with the principles of limit state design. The selected design situations should be sufficiently Severe and varied so as to encompass all reasonable conditions which can be foreseen during the period of construction and the life of the retaining wall. 3.1.2 Limit state design This code of practice adopts the philosophy of limit state design. This philosophy does not impose upon the designer any special requirements as to the manner in which the safety and stability of the retaining wall may be achieved, whether by overall factors of safety, or partial factors of safety, or by other measures. Limit states (see 1.3.13) are classified into: a) ultimate limit states (see 3.1.3); b) serviceability limit states (see 3.1.4). Typical ultimate limit states are depicted in figure 3. Rupture states which are reached before collapse occurs are, for simplicity, also classified and

JAVA思想外文翻译毕业设计

文献来源：Bruce Eckel.Thinking in Java [J]. Pearson Higher Isia Education,2006-2-20. Java编程思想 (Java和因特网) 既然Java不过另一种类型的程序设计语言，大家可能会奇怪它为什么值得如此重视，为什么还有这么多的人认为它是计算机程序设计的一个里程碑呢？如果您来自一个传统的程序设计背景，那么答案在刚开始的时候并不是很明显。Java除了可解决传统的程序设计问题以外，还能解决World Wide Web(万维网) 上的编程问题。 1、客户端编程 Web最初采用的“服务器－浏览器”方案可提供交互式内容，但这种交互能力完全由服务器提供，为服务器和因特网带来了不小的负担。服务器一般为客户浏览器产生静态网页，由后者简单地解释并显示出来。基本HTML语言提供了简单的数据收集机制：文字输入框、复选框、单选钮、列表以及下拉列表等，另外还有一个按钮，只能由程序规定重新设置表单中的数据，以便回传给服务器。用户提交的信息通过所有Web服务器均能支持的“通用网关接口”（CGI）回传到服务器。包含在提交数据中的文字指示CGI该如何操作。最常见的行动是运行位于服务器的一个程序。那个程序一般保存在一个名为“cgi-bin”的目录中（按下Web页内的一个按钮时，请注意一下浏览器顶部的地址窗，经常都能发现“cgi-bin”的字样）。大多数语言都可用来编制这些程序，但其中最常见的是Perl。这是由于Perl是专为文字的处理及解释而设计的，所以能在任何服务器上安装和使用，无论采用的处理器或操作系统是什么。 2、脚本编制语言插件造成了脚本编制语言的爆炸性增长。通过这种脚本语言，可将用于自己客户端程序的源码直接插入HTML页，而对那种语言进行解释的插件会在HTML 页显示的时候自动激活。脚本语言一般都倾向于尽量简化，易于理解。而且由于它们是从属于HTML页的一些简单正文，所以只需向服务器发出对那个页的一

Java的面向对象编程外文资料翻译

毕业设计(论文)外文资料翻译系：计算机系专业：计算机科学与技术姓名：学号：外文出处：Ghosh,D..Java Object-oriented (用外文写) programming[J]. IEEE Transactions on Software Engineering,2009, 13(3):42-45. 附件： 1.外文资料翻译译文；2.外文原文。

注：请将该封面与附件装订成册。

附件1：外文资料翻译译文 Java的面向对象编程 ——面向对象编程和它的关键技术—继承和多态性软件的重用可以节省程序开发时间。它鼓励重复使用已经调试好的高质量的软件，从而减少系统运行后可能出现的问题。这些都是令人振奋的可能性。多态性允许我们用统一的风格编写程序，来处理多种已存在的类和特定的相关类。利用多态性我们可以方便地向系统中添加新的功能。继承和多态对于解决软件的复杂性是一种有效可行的技术。当创建一个新的类时，而不用完整的写出新的实例变量和实例方法，程序员会指定新的类继承已定义的超类的实例变量和实例方法。这个新的类被称为一个子类。每个子类本身将来亦可有新的子类，而其本身将成为父类。一个类的直接父类就是该类所直接继承的类（通过关键字extends继承）。一个间接超类是通过从两级或更多级以上的类继承而来的。例如，从类JApplet（包javax.swing 中）扩展来的类Applet（包java.applet）。一个类单一的从一个父类继承而来。 Java 不支持多重继承（而C++可以），但它支持接口的概念。接口可以使Java实现许多通过多重继承才能实现的优点而没有关联的问题。我们将在本章讨论的接口的详细内容。我们会给出创建和使用接口的一般规律和具体实例。一个子类通常添加自己的实例变量和自己的实例方法，因此子类通常比父类大。一个子类比它的父类更具体并且代表一组更小、更专业的对象。通过单一继承，子类在开始时拥有父类的所有特性。继承性真正的力量在于它可以在定义子类时增加或取代从超类中继承来的特征。每个子类对象也是该类的父类的对象。例如，每一个我们所定义的小程序被认为是类JApplet 的对象。此外，因为Japplet继承了Applet，每一个我们所定义的小程序同时也被认为是一个Applet 的对象。当开发applets时，这些信息是至关重要的，因为一个小程序容器只有当它是一个Applet才可以执行一个程序。虽然子类对象始终可以作为它的父类的一种来看待，父类对象却不被认为是其子类类型的对象。我们将利用这种“子类对象是父类对象”的关系来执行一些强大的操作。例如，绘图程序可以显示一系列图形，如果所有的图形类型都直接或间接地继

毕业设计(论文)外文翻译(译文)

编号：桂林电子科技大学信息科技学院毕业设计(论文)外文翻译（译文）系（部）：机电工程系专业：机械设计制造及自动化学生姓名：李汉显学号：1153100506 指导教师单位：桂林航天工业学院姓名：陈志职称：讲师 2015年5 月28日

无损检测技术在检测石油管道时的可靠性卡瓦略·库切答（a）；雷贝洛（b）；米纳拉辛苏扎·苏哲（b）；湖奈保尔·苏格瑞勒（c）；萨拉?迪基·苏亚雷斯（d） a、华盛顿苏亚雷斯马路大学科学技术中心，1321；巴西福塔雷萨行政长官,埃德森奎罗兹临时选举委员会:60,811 - 905 b、巴西里约热内卢联邦大学临时选举委员会:21941 - 972 c、巴西里约热内卢联邦大学土木工程系 d、巴西里约热内卢大学城临时选举委员会:21949 - 900 文章内容文章背景：2006年11月9日收到 2008年5月21日修改后的表格 2008年5月27日认可关键词：无损检测；可靠性；超声检测；X线摄影摘要这项工作的目的是评估无损检测技术（NDT）在检查石油工业中的管道焊缝的可靠性。X射线，手动和全自动的超声波都利用了脉冲回波和光线干涉原理。三个层面的缺陷分析为：缺乏渗透（LP），缺乏融合（LF）和削弱（UC）。这些测试是对含焊缝缺陷已被人为地确定为标本的管道进行测试。结果表明：全自动超声波检测缺陷与手动超声波、X光测试相比更具有优越性。此外，人工神经网络已被用于探测缺陷和缺陷的自动分类。 1简介在长距离的流体（包括石油和天然气）传输过程中，管道运输时最安全最经济的方法。由于这一点和管道的效率，他们已用了几十年。但是由于种种因素，如腐蚀，疲劳，甚至侵蚀所增加泄漏的危险，甚至破裂，这些都是现在应该考虑的关键问题。还应该指出，许多管道铺设在接近道路，铁路，水路甚至在城市或在其下方。因此，必须有方法监测，评价和肯定管道的完整性，减少泄漏的风险，从而避免环境破坏和人群危害。多年来，无损检测在石油管道的状态检测中显示了其高效性。无损检测技术正被研究的越来越深，同时已经作为评估工程结构、工程系统使用寿命的方法。这项研究特别注意了石油工业可能发生的设备故障导致严重后果，比如环境污染和人员伤亡。然而，一般认为应考虑采取最适当的参数来选择无损技术，剩下的就是它的使用可靠性，其中一个检测与确定缺陷大小的评估检测概率曲线（POD）是最具代表性的。对于管道检测的两种技术超声波和X线检查比传统方法更具有出色的效率和易于

java外文翻译

毕业设计外文资料翻译（译文）题目名称：Java and the Internet 学院：计算机科学技术专业年级：计算机科学与技术（师）08 级学生姓名：aaa 班级学号：a班a号指导教师：aaa

二○一一年五月十三日译文题目：Java和因特网原文题目：Java and the Internet 原文出处：https://www.sodocs.net/doc/d014329295.html,/view.html

Java and the Internet If Java is, in fact, yet another computer programming language, you may question why it is so important and why it is being promoted as a revolutionary step in computer programming. The answer isn’t immediately obvious if you’re coming from a traditional programming perspective. Although Java is very useful for solving traditional stand-alone programming problems, it is also important because it will solve programming problems on the World Wide Web. 1.Client-side programming The Web’s initial server-browser design provided for interactive content, but the interactivity was completely provided by the server. The server produced static pages for the client browser, which would simply interpret and display them. Basic HTML contains simple mechanisms for data gathering: text-entry boxes, check boxes, radio boxes, lists and drop-down lists, as well as a button that can only be programmed to reset the data on the form or “submit” the data on the form back to the server. This submission passes through the Common Gateway Interface (CGI) provided on all Web servers. The text within the submission tells CGI what to do with it. The most common action is to run a program located on the server in a directory that’s typically called “cgi-bin.” (If you watch the address window at the top of your browser when you push a button on a Web page, you can so metimes see “cgi-bin” within all the gobbledygook there.) These programs can be written in most languages. Perl is a common choice because it is designed for text manipulation and is interpreted, so it can be installed on any server regardless of processor or operating system. Many powerful Web sites today are built strictly on CGI, and you can in fact do nearly anything with it. However, Web sites built on CGI programs can rapidly become overly complicated to maintain, and there is also the problem of response time. The response of a CGI program depends on how much data must be sent, as well as the load on both the server and the Internet. (On top of this, starting a CGI program tends to be slow.) The initial designers of the Web did not foresee how rapidly this bandwidth would be exhausted for the kinds of applications people developed. For example, any sort of dynamic graphing is nearly impossible to perform with consistency because a GIF file must be created and moved from the server to the client for eac h version of the graph. And you’ve no doubt had direct experience with something as simple as validating the data on an input form. You press the submit button on a page; the data is shipped back to the server; the server starts a CGI program that discovers an error, formats an HTML page informing you of the error, and then sends the page back to you; you must then back up a page and try again. Not only is this slow, it’s inelegant. The solution is client-side programming. Most machines that run Web browsers are powerful engines capable of doing vast work, and with the original static HTML

15000字的Java外文翻译

xxxx大学高新学院毕业设计（论文）外文翻译学生姓名：院（系）：专业班级：指导教师：完成日期：

JSP基础学习资料一、JSP 技术概述在Sun 正式发布JSP(JavaServer Pages) 之后，这种新的Web 应用开发技术很快引起了人们的关注。JSP 为创建高度动态的Web 应用提供了一个独特的开发环境。按照Sun 的说法，JSP 能够适应市场上包括Apache WebServer 、IIS4.0 在内的85% 的服务器产品。即使您对ASP “一往情深”，我们认为，关注JSP 的发展仍旧很有必要。㈠JSP 与ASP 的简单比较 JSP 与Microsoft 的ASP 技术非常相似。两者都提供在HTML 代码中混合某种程序代码、由语言引擎解释执行程序代码的能力。在ASP 或JSP 环境下，HTML 代码主要负责描述信息的显示样式，而程序代码则用来描述处理逻辑。普通的HTML 页面只依赖于Web 服务器，而ASP 和JSP 页面需要附加的语言引擎分析和执行程序代码。程序代码的执行结果被重新嵌入到HTML 代码中，然后一起发送给浏览器。ASP 和JSP 都是面向Web 服务器的技术，客户端浏览器不需要任何附加的软件支持。 ASP 的编程语言是VBScript 之类的脚本语言，JSP 使用的是Java ，这是两者最明显的区别。此外，ASP 与JSP 还有一个更为本质的区别：两种语言引擎用完全不同的方式处理页面中嵌入的程序代码。在ASP 下，VBScript 代码被ASP 引擎解释执行；在JSP 下，代码被编译成Servlet 并由Java 虚拟机执行，这种编译操作仅在对JSP 页面的第一次请求时发生。㈡运行环境 Sun 公司的JSP 主页在https://www.sodocs.net/doc/d014329295.html,/products/jsp/index.html ，从这里还可以下载JSP 规范，这些规范定义了供应商在创建JSP 引擎时所必须遵从的一些规则。执行JSP 代码需要在服务器上安装JSP 引擎。此处我们使用的是Sun 的JavaServer Web Development Kit （JSWDK ）。为便于学习，这个软件包提供了大量可供修改的示例。安装JSWDK 之后，只需执行startserver 命令即可启动服务器。在默认配置下服务器在端口8080 监听，使用http://localhost:8080 即可打开缺省页面。在运行JSP 示例页面之前，请注意一下安装JSWDK 的目录，特别是“ work ”子目录下的内容。执行示例页面时，可以在这里看到JSP 页面如何被转换成Java 源文件，然后又被编译成class 文件（即Servlet ）。JSWDK 软件包中的示例页

大学本科毕业设计文献翻译模板

模型预测油田水中溶解的碳酸钙含量：压力和温度的影响 XXX 译摘要：油田中水垢沉积会对储层造成伤害、堵塞地层孔道、表面以及注入设备。碳酸钙是水中最常见的结垢化合物之一，储层产生的盐水会使压力和温度降低，储层压力降低会使CaCO3的溶解度降低，进而提高体系中碳酸钙的饱和速率，而温度下降会产生相反的结果。因此温度和压力一起作用的结果可能增加或减小CaCO3溶解度，用体系温度的变化来指定其压力的变化。因此，在石油生产系统中精确的预测方法的应用备受关注。目前的研究重点是运用基于最小二乘支持向量机(LSSVM)预测模型来估计油田水中溶解碳酸钙浓度的大小。用超优化参数（r和C2）的遗传算法（GA）嵌入到LSSVM模型，这种方法可简单准确的预测油田卤水中溶解碳酸钙浓度的最小量。 1.引言随着油田卤水压力和温度变化，气体可能会从储层到地表的运动，导致某些固体沉淀。为了保持注水井压力平衡并将油运移到生产井，有时需要将卤水注入到储层中，因此，过量的盐垢可以沉积在储层或井眼内。对于大部分油田结垢多会发生在此过程中。碳酸钙沉积通常是一个自发的过程，沉积形成的主要原因是二氧化碳从水相逸出，导致油气层的压力下降，该过程会除去了水中的碳酸，直到方解石溶解完全。在恒定二氧化碳分压下，方解石的溶解性随温度的降低而降低[1-4]。根据公式（1），碳酸钙沉积垢来自碳酸钙沉淀： Ca2+ + CO32-→ CaCO3↓ 下面的公式为碳酸的电离式[5–7]： CO2 + H2O → H2CO3 H2CO3→ H+ + HCO3- HCO3-→ H+ + CO32- 若要形成碳酸氢根离子和氢离子，碳酸要电离，因为碳酸的第一电离常数远大于它的第二电离常数，从碳酸第一电离离子化的氢离子与水中自由的碳酸根离子结合。此外，碳酸钙沉淀的方程式可以说明[8–10]：