开心编程网

　    主要有三个问题：
　　1，struts中资源文件中如果value为中文，显示乱码
　　解决办法：使用eclipse插件Properties Editor
　　2，在文本域里输入中文显示乱码
　　解决办法：使用servlet过滤器filter
　　最简单的可以借用tomcat下面的filters.SetCharacterEncodingFilter在自己的web.xml配置中加入tomcat中servlet_examples相应配置(高手可以自己配!)
　　本人配置如下：
　　SetCharacterEncoding
　　filters.SetCharacterEncodingFilter
　　encoding
　　GBK
　　SetCharacterEncoding
　　*.do
　　3，从某些数据库里读出乱码
　　解决办法：把你要显示成中文的部分重新编码
　　例如：

  　while (rs.next())
　　{
　　String col1 = rs.getString(1);
　　String col2 = rs.getString(2);
　　String col3 = rs.getString(3);
　　float col4 = rs.getFloat(4);
　　//convert character encoding
　　col1=new String(col1.getBytes(“ISO-8859-1″),”GB2312″);
　　col2=new String(col2.getBytes(“ISO-8859-1″),”GB2312″);
　　col3=new String(col3.getBytes(“ISO-8859-1″),”GB2312″);
　　｝

      Spring 和EJB争吵终于即将结束：Spring将支持EJB3.1标准，Spring will also be a full featured EJB 3.1 implementation for use in the WebLogic application server.这场融合将在javaEE 6实现，这个融合和当初Hibernate与JPA融合一样水到渠成。
      Spring创始人Rod Johnson 说Spring 2.5的dependency injection annotations是学习得益于EJB 3.0的 @Resource 和 Google’s Guice，我不知道他为什么没有提picocontainer，至少他的Spring 2.5开始直接大胆使用DI的auto wiring（而这个功能在Spring 1.X中还是可选功能），而2005年我的Jdon框架就完全是auto wiring。

       Rod Johnson 鼓励开发者使用EJB标准，比如 @PostConstruct 和 @PreDestroy annotations，因为他们是标准化的，Spring已经支持他们（Spring才支持它们？今天才明白？），这些都意味着Spring和EJB争吵的结束。
      其实EJB的@PostConstruct @PreDestroy @Resource 这样annotations都可以在EJB2中找到影子和原根，表现语法不一样，但是内部机制原理是一致的。所以，以前没有学过EJB的，看来还是要补这一课。
      PostConstruct和PreDestroy都是在对象生命周期开始以及结束让程序员能够进行一些状态管理，比如开始一些场景准备和加载，或者结束后，释放一些资源，防止内存泄漏，这些都是从EJB1.X 无态Bean开始就有的功能，不过当初是使用XML配置，并且无论程序员实现与否，一定要写这几个方法，现在通过注解 annotation 加在你需要实现的方法上，更加简洁方便。
      所以，我以前说：如果说EJB1/EJB2X是一个定型的女孩的话；那么EJB3引入IOC/DI依赖注射和annotation以后，就更漂亮，更加吸引程序员接近她，也非常容易和其打交道了。
      EJB从开始诞生起，因为高低各种原因，被高端和低端各种人怀疑打击，真正是遭受了不公平待遇，
      高端专家比如Martin Fowler因为其不宜测试，提出POJO思想，认为对象应该不依赖平台，应该是一个个光溜溜来去无牵挂的，不继承任何框架接口等。不可否认POJO促进了EJB3变得更漂亮，但是EJB内在分布式计算组件的重点没有变。
      在低端程序员中，EJB以其深奥的原理和超前的设计思维，更不能被他们理解，他们甚至以一种僵化思维来看：现实80%不是大系统，不需要集群分布式计算。
     [...]

    下述十四个技巧，是许多人在大量的数据库分析与设计实践中，逐步总结出来的。对于这些经验的运用，读者不能生帮硬套，死记硬背，而要消化理解，实事求是，灵活掌握。并逐步做到：在应用中发展，在发展中应用。
      1. 原始单据与实体之间的关系
　　
      可以是一对一、一对多、多对多的关系。在一般情况下，它们是一对一的关系：即一张原始单据对应且只对应一个实体。在特殊情况下，它们可能是一对多或多对一的关系，即一张原始单证对应多个实体，或多张原始单证对应一个实体。这里的实体可以理解为基本表。明确这种对应关系后，对我们设计录入界面大有好处。
      〖例1〗：一份员工履历资料，在人力资源信息系统中，就对应三个基本表：员工基本情况表、社会关系表、工作简历表。这就是“一张原始单证对应多个实体”的典型例子。
      2. 主键与外键
　　
      一般而言，一个实体不能既无主键又无外键。在E?R 图中, 处于叶子部位的实体, 可以定义主键，也可以不定义主键(因为它无子孙), 但必须要有外键(因为它有父亲)。
　　
      主键与外键的设计，在全局数据库的设计中，占有重要地位。当全局数据库的设计完成以后，有个美国数据库设计专家说：“键，到处都是键，除了键之外，什么也没有”，这就是他的数据库设计经验之谈，也反映了他对信息系统核心(数据模型)的高度抽象思想。因为：主键是实体的高度抽象，主键与外键的配对，表示实体之间的连接。
      3. 基本表的性质
　　
      基本表与中间表、临时表不同，因为它具有如下四个特性：
　　
        (1) 原子性。基本表中的字段是不可再分解的。
　　    (2) 原始性。基本表中的记录是原始数据（基础数据）的记录。
　　    (3) 演绎性。由基本表与代码表中的数据，可以派生出所有的输出数据。
　　    (4) 稳定性。基本表的结构是相对稳定的，表中的记录是要长期保存的。
      理解基本表的性质后，在设计数据库时，就能将基本表与中间表、临时表区分开来。
      4. 范式标准
　
      基本表及其字段之间的关系, 应尽量满足第三范式。但是，满足第三范式的数据库设计，往往不是最好的设计。为了提高数据库的运行效率，常常需要降低范式标准：适当增加冗余，达到以空间换时间的目的。
      〖例2〗：有一张存放商品的基本表，如表1所示。“金额”这个字段的存在，表明该表的设计不满足第三范式，因为“金额”可以由“单价”乘以“数量”得到，说明“金额”是冗余字段。但是，增加“金额”这个冗余字段，可以提高查询统计的速度，这就是以空间换时间的作法。
　　
      在Rose 2002中，规定列有两种类型：数据列和计算列。“金额”这样的列被称为“计算列”，而“单价”和“数量”这样的列被称为“数据列”。
　　
      表1 商品表的表结构
　　  商品名称 商品型号 单价 数量 金额
　　  电视机 29? 2,500 40 100,000
　　
      5. 通俗地理解三个范式
　　
      通俗地理解三个范式，对于数据库设计大有好处。在数据库设计中，为了更好地应用三个范式，就必须通俗地理解三个范式(通俗地理解是够用的理解，并不是最科学最准确的理解)：
　　
          第一范式：1NF是对属性的原子性约束，要求属性具有原子性，不可再分解；
　　  第二范式：2NF是对记录的惟一性约束，要求记录有惟一标识，即实体的惟一性；
　　  第三范式：3NF是对字段冗余性的约束，即任何字段不能由其他字段派生出来，它要求字段没有冗余.
     没有冗余的数据库设计可以做到。但是，没有冗余的数据库未必是最好的数据库，有时为了提高运行效率，就必须降低范式标准，适当保留冗余数据。具体做法是：在概念数据模型设计时遵守第三范式，降低范式标准的工作放到物理数据模型设计时考虑。降低范式就是增加字段，允许冗余。
      6. 要善于识别与正确处理多对多的关系
     
      若两个实体之间存在多对多的关系，则应消除这种关系。消除的办法是，在两者之间增加第三个实体。这样，原来一个多对多的关系，现在变为两个一对多的关系。要将原来两个实体的属性合理地分配到三个实体中去。这里的第三个实体，实质上是一个较复杂的关系，它对应一张基本表。一般来讲，数据库设计工具不能识别多对多的关系，但能处理多对多的关系。
      [...]

　　事实上网络编程简单的理解就是两台计算机相互通讯数据而已.对于程序员而言,去掌握一种编程接口并使用一种编程模型相对就会显得简单的多了.Java SDK提供一些相对简单的Api来完成这些工作.Socket就是其中之一.对于Java而言.这些Api存在与java.net 这个包里面.因此只要导入这个包就可以准备网络编程了.
网络编程的基本模型就是客户机到服务器模型.简单的说就是两个进程之间相互通讯,然后其中一个必须提供一个固定的位置,而另一个则只需要知道这个固定的位置.并去建立两者之间的联系..然后完成数据的通讯就可以了.这里提供固定位置的通常称为服务器,而建立联系的通常叫做客户端.基于这个简单的模型,就可以进入网络编程啦.
Java对这个模型的支持有很多种Api.而这里我只想介绍有关Socket的编程接口.对于Java而言已经简化了Socket的编程接口.首先我们来讨论有关提供固定位置的服务方是如何建立的.Java提供了ServerSocket来对其进行支持.事实上当你创建该类的一个实力对象并提供一个端口资源你就建立了一个固定位置可以让其他计算机来访问你.ServerSocket server=new ServerSocket(6789);这里稍微要注意的是端口的分配必须是唯一的.因为端口是为了唯一标识每台计算机唯一服务的.另外端口号是从0~65535之间的,前1024个端口已经被Tcp/Ip 作为保留端口,因此你所分配的端口只能是1024个之后的.好了.我们有了固定位置.现在所需要的就是一根连接线了.该连接线由客户方首先提出要求.因此Java同样提供了一个Socket对象来对其进行支持.只要客户方创建一个Socket的实例对象进行支持就可以了.Socket client
=new Socket(InetAddress.getLocalHost(),5678);客户机必须知道有关服务器的IP地址.对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供.它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法.
好了.上面的方法基本可以建立一条连线让两台计算机相互交流了.可是数据是如何传输的呢?事实上I/O操作总是和网络编程息息相关的.因为底层的网络是继续数据的.除非远程调用,处理问题的核心在执行上.否则数据的交互还是依赖于IO操作的.所以你也必须导入java.io这个包.java的IO操作也不复杂.它提供了针对于字节流和Unicode的读者和写者,然后也提供了一个缓冲用于数据的读写.
BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream()));
PrintWriter out=new PrintWriter(server.getOutputStream());
上面两句就是建立缓冲并把原始的字节流转变为Unicode可以操作.而原始的字节流来源于Socket的两个方法.getInputStream()和getOutputStream()方.分别用来得到输入和输出.那么现在有了基本的模型和基本的操作工具.我们可以做一个简单的Socket例程了.
服务方:
import java.io.*;
import java.net.*;
public class MyServer {
public static void main(String[] args) throws IOException{
ServerSocket server=new ServerSocket(5678);
Socket client=server.accept();
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter out=new PrintWriter(client.getOutputStream());
while(true){
String str=in.readLine();
System.out.println(str);
out.println(“has receive….”);
out.flush();
if(str.equals(“end”))
break;
}
client.close();
}
}
这个程序的主要目的在于服务器不断接收客户机所写入的信息只到.客户机发送”End”字符串就退出程序.并且服务器也会做出”Receive”为回应.告知客户机已接收到消息.
客户机代码:
import java.net.*;
import java.io.*;
public class Client{
static Socket server;
public static void main(String[] args)throws Exception{
server=new Socket(InetAddress.getLocalHost(),5678);
BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream()));
PrintWriter out=new PrintWriter(server.getOutputStream());
BufferedReader wt=new BufferedReader(new [...]

其实这个问题我原来翻译（破除java神话之二：参数是传址的 ）、转帖别人的详细解释（Java 应用程序中的按值传递语义 ）和专门解释（ 我对《Java 应用程序中的按值传递语义》的理解 ）过，不过现在看来，原来翻译或者解释的角度是有问题的，从底层的角度解释并不直观，在交流的时候也容易引起误解，最终不能达成一致意见。下面以最终的效果来解释参数的传递方式：
1、对于原始数据类型，也就是int、 long、char之类的类型，是传值的，如果你在方法中修改了值，方法调用结束后，那个变量的值没用改变。
2、对于对象类型，也就是Object的子类，如果你在方法中修改了它的成员的值，那个修改是生效的，方法调用结束后，它的成员是新的值，但是如果你把它指向一个其它的对象，方法调用结束后，原来对它的引用并没用指向新的对象。
代码如下：
public class Tester {
    public static void main(String[] args) {
        int primitive = 2;
        changePrimitive(primitive);
        //primitive的值依然是2
        MyClass myClass = new MyClass();
        changeObject(myClass);
        //myClass仍然指向的是执行changeObject之前的那个对象
        //但是myClass.i等于3了
    }
    public static void changePrimitive(int primitive) {
        primitive = 3;
    }
    public static void changeObject(MyClass myClass) {
        myClass.i = 3;
        myClass = new MyClass();
    }
}
class MyClass [...]

　　在java中实质只存在一种传递方式：即值传递。 而引用传递是对C/C++而言的。结论：
　　对于基本类型，在方法体内对方法参数进行重新赋值，并不会改变原有变量的值。
　　对于引用类型，在方法体内对方法参数进行重新赋予引用，并不会改变原有变量所持有的引用。
　　方法体内对参数进行运算，不影响原有变量的值。
　　方法体内对参数所指向对象的属性进行运算，将改变原有变量所指向对象的属性值。
　　在JAVA中变量有以下两种：
　　基本类型变量，包括char、byte、short、int、long、float、double、boolean。
　　引用类型变量，包括类、接口、数组（基本类型数组和对象数组）。
　　最后我们得出如下的结论：
　　基本类型和基本类型变量被当作参数传递给方法时，是值传递。在方法实体中，无法给原变量重新赋值，也无法改变它的值。
　　对象和引用型变量被当作参数传递给方法时，在方法实体中，无法给原变量重新赋值，但是可以改变它所指向对象的属性。
　　 public class Person
　　{
　　 private String name = null;
　　private int age = 0;
　　public Person(String name, int age) {
　　 this.name = name;
　　this.age = age;
　　}
　　 public void changeName(String newName) {
　　 this.name = newName;
　　 }
　　 public void changeAge(int newAge) {
　　 this.age = newAge;
　　 }
　　public String toString() {
　　 return “Person – Name: ” + name + “, Age: [...]

　　spring.jar是包含有完整发布的单个jar包，spring.jar中包含除了 spring-mock.jar里所包含的内容外其它所有jar包的内容，因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试，正式应用系统中是用不得这些类的。
　　除了spring.jar文件，Spring还包括有其它13个独立的jar包，各自包含着对应的Spring组件，用户可以根据自己的需要来选择组合自己的jar包，而不必引入整个spring.jar的所有类文件。
　　(1) spring-core.jar
　　这个jar文件包含Spring框架基本的核心工具类，Spring其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。
　　(2) spring-beans.jar
　　这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring- beans.jar文件就可以了。
　　(3) spring-aop.jar
　　这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。
　　(4) spring-context.jar
　　这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI所需的全部类，UI方面的用来与模板（Templating）引擎如 Velocity、FreeMarker、JasperReports集成的类，以及校验Validation方面的相关类。
　　(5) spring-dao.jar
　　这个jar文件包含Spring DAO、Spring Transaction进行数据访问的所有类。为了使用声明型事务支持，还需在自己的应用里包含spring-aop.jar。
　　(6) spring-hibernate.jar
　　这个jar文件包含Spring对Hibernate 2及Hibernate 3进行封装的所有类。
　　(7) spring-jdbc.jar
　　这个jar文件包含对Spring对JDBC数据访问进行封装的所有类。
　　(8) spring-orm.jar
　　这个jar文件包含Spring对DAO特性集进行了扩展，使其支持 iBATIS、JDO、OJB、TopLink，因为Hibernate已经独立成包了，现在不包含在这个包里了。这个jar文件里大部分的类都要依赖 spring-dao.jar里的类，用这个包时你需要同时包含spring-dao.jar包。 
　　(9) spring-remoting.jar
　　这个jar文件包含支持EJB、JMS、远程调用Remoting（RMI、Hessian、Burlap、Http Invoker、JAX-RPC）方面的类。
　　(10) spring-support.jar
　　(11) spring-web.jar
　　这个jar文件包含Web应用开发时，用到Spring框架时所需的核心类，包括自动载入WebApplicationContext特性的类、Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。
　　(12) spring-webmvc.jar
　　这个jar文件包含Spring MVC框架相关的所有类。包含国际化、标签、Theme、视图展现的FreeMarker、JasperReports、Tiles、Velocity、 XSLT相关类。当然，如果你的应用使用了独立的MVC框架，则无需这个JAR文件里的任何类。
　　(13) spring-mock.jar
　　这个jar文件包含Spring一整套mock类来辅助应用的测试。Spring测试套件使用了其中大量mock类，这样测试就更加简单。模拟HttpServletRequest和HttpServletResponse类在Web应用单元测试是很方便的。
　　如何选择这些发布包，决定选用哪些发布包其实相当简单。如果你正在构建Web应用并将全程使用Spring，那么最好就使用单个全部的 spring.jar文件；如果你的应用仅仅用到简单的Inversion of Control / Dependency Injection（IoC/DI）容器，那么只需spring-core.jar与spring-beans.jar即可；如果你对发布的大小要求很高，那么就得精挑细选了，只取包含自己所需特性的jar文件了。采用独立的发布包你可以避免包含自己的应用不需要的全部类。当然你可以采用其它的一些工具来设法令整个应用包变小，节省空间的重点在于准确地找出自己所需的Spring依赖类，然后合并所需的类与包就可以了。Eclispe有个插件叫 ClassPath Helper可以帮你找找所依赖的类。
Spring包依赖说明:
　　1) spring-core.jar需commons-collections.jar，spring-core.jar是以下其它各个的基本。
　　2) spring-beans.jar需spring-core.jar，cglib-nodep-2.1_3.jar
　　3) spring-aop.jar需spring-core.jar，spring-beans.jar，cglib-nodep-2.1_3.jar，aopalliance.jar
　　4) spring-context.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，commons-collections.jar，aopalliance.jar
　　5) spring-dao.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，spring-context.jar
　　6) spring-jdbc.jar需spring-core.jar，spring-beans.jar，spring-dao.jar
　　7) spring-web.jar需spring-core.jar，spring-beans.jar，spring-context.jar
　　8) spring-webmvc.jar需spring-core.jar/spring-beans.jar/spring-context.jar/spring-web.jar
　　9) spring -hibernate.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，spring- dao.jar，spring-jdbc.jar，spring-orm.jar，spring-web.jar，spring-webmvc.jar
　　10) spring-orm.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，spring- dao.jar，spring-jdbc.jar，spring-web.jar，spring-webmvc.jar
　　11) [...]

Java面向对象试题分析
 
说明： 
       （1）考试时间为2小时。
       （2）除简答题和编程题外，所有答案均可直接写在试卷上。
       （3）简答题和编程题写在试卷后所附的答题纸上，标明题号。
       （4）要求代码书写规范，并添加相应的注释。
       （5）特设卷面整洁分，凡卷面不整洁导致代码及文字难于识别者，扣除5分。
点评：
         虽然再三强调，但仍有同学的试卷乱得一塌糊涂，由于这些同学本身的分数就不高，所以这部分就不扣分了。
         我个人认为，如果卷面整洁，说明这个人办事比较有条理，同学们要注意这些细节，有的时候，细节决定成败。
       （6）部分题目没有标准答案，只要言之成理，均可给分。
点评：
         没有标准答案不等于允许你乱写。有些同学的回答与题目风马牛不相及，逻辑混乱，反映出他需要加强文字表达能力方面的训练。
*******************************************************************************
一、判断题（正确的描述打钩，错误的打叉，每题1分，共10分） 
1 抽象类中不可以有非抽象的方法。   （错）
2 如果将一个对象强制类型转换为一个不兼容的类型，将引发NullPointerException
  异常。    （错）
3 Java中Object类是最顶层的类。 （对）
4 程序在编译通过以后，仍然可能出现运行时错误和逻辑错误。   （对）
5 可以通过javac来运行一个Java Application。  （错）
6 可以在子类构造函数中通过this关键字调用基类的构造函数。   （错）
7 Java语言是IBM公司设计的一种面向对象程序设计语言。（错）
8 一个Unicode字符占4个字节。  （错）
9 在循环语句中，使用continue;语句可以跳出循环。   （错）
10 在Java Application中如果没有定义main()方法，则程序不能编译。 （错）
点评：
    这10道题没什么好说的，都是知识性的题目。
二、简答题（请将答案写到答题纸上，注明题号。每题3分，共30分）
1  请看以下代码:
    package mytest;
    public class Main {
         public static void main(String[] args) {
             System.out.println(new A());
             }
    }
    class [...]

       我一直认为基础知识最重要,无论是对国家,还是对个人的后期发展,都是最重要的.有些人自以为是,以为会玩玩struts,hibernate之类的工具,就觉得自己不得了,其实,那算什么,一个用高级工具的用户而已,如果中国全是这样的高级用户,中国软件永远不会有出头之日,永远只能用别人做好的工具!非常遗憾的是,我搞这些基础知识的”研究”,常常引来一些讥讽声和嘲笑声,不过,这些讥讽声和嘲笑声并不能左右我的思想!我没必要为去迎合那些无知和没有远见的人(不是攻击别人,而我就是这么想的)而改变自己的立场和理念!
       我现在不算精通struts,hibernate,spring,但是,还算学得明白,照着一些现有的书籍和别人的思路讲讲课,应该不会有什么问题.我并不觉得这样就有什么资本,我从未钦佩过那些使用struts,hibernate,spring的大虾们,而是只佩服当初开发struts,hibernate,spring这些框架的大侠们.佩服那些对这些框架的内部原理有深入研究的技术牛人们!我在学习struts和spring时,发现这些框架的设计师们对html,css,javascript,http协议,servlet,jsp,java等基础性知识掌握得都非常全面,并且细节都非常清楚,敢问国内那些看不上这些基础知识的人们,为何struts和spring设计师们都觉得这些知识重要,而你却认为不重要,说句不客气的话,因为你还连一点概念都没有,你永远到不了struts和spring设计师们的水平,我虽达不到他们的水平,至少我可以追随他们的思想,读懂他们的源码,知道他们为何要这么做!
     每个人都可以有自己的想法,但没必要把自己的想法强加给其他人!

　　实体是一个可持久化的域对象。程序出来产物就是实体类，实体类可以作为一个辅助类，如可作为一个实体类的助手类或者作为代表实体类的状态的类。
　　实体类的要求
　　·实体类必须用entity标识符来声明，或者在配制文件中指明某个类为实体类。
　　·实体类必须有一个无参数的构造器。它也可以有其他的构造器。这个无参数的构造器必须是public或protected的。
　　·如果实体实例作为一个分离对象按值传递(如通过一个远程接口)，则实体类必须实现serializable接口。
　　·实体类不允许是final的，它的所有方法都不允许是final的。
　　·实体支持继承，多义关联，多义查询。实体类可以是抽象的，也可以是具体的。实体类可以继承非实体类，非实体类也可以继承实体类。
　　·实体的状态由它的变量代表，这是和JavaBean的属性一样的。实体方法可以直接获得变量，但是实体的客户端必须通过获取变量的方法(getter/setter)来获取变量。实例变量必须是private，protected或包内可见的。
　　1、持久化字段和属性
　　实体的状态可以通过它的setter/getter方法或实例变量获得，这两种方式通称为运行时持久化提供器(指持久化实现的运行环境，在EJB环境中，可能是EJB容器，也可能是第三方提供的集成在EJB容器内的持久化实现)：
　　·如果声明实体的标识符的元素值为access=FIELD，那么运行时持久化提供器直接获取实例变量，并且持久化所有non-transient实例变量(没有用Transient标识符标识的变量)。
　　·如果声明实体的标识符的元素值为access=PROPERTY，或者没有指定access的值，那么运行时持久化提供器通过getter/setter方法获取实例变量，并且持久化所有non-transient实例变量(没有用Transient标识符标识的变量)。所有的属性获取方法必须是public或protected。
　　·当使用FIELD类型时，O/R影射标识符用在变量上。当用PROPERTY时，O/R影射标识符用在getter/setter方法上。(注意：当在加载或存储持久化状态时，持久化提供者按照什么样的顺序来调用这些方法是不确定的。因此包含在这些方法内的业务逻辑不能依赖指定的调用顺序)。
　　当使用持久化属性时，要求实体遵循JavaBean的方法约定。在这种情况下，实体的类型T的每一个持久化属性property，都有一个getter方法getProperty和一个setter方法setProperty，对于boolean值则为isProperty。
　　对于简单值得持久化属性，这些方法如下形式：
　　对于集合类型的字段和属性，则必须用java.util.Collection接口定义，不管实体类是否遵循JavaBean的规范。下面的接口都是可以的：java.util.Collection，java.util.List，java.util.Set，java.util.Map。
　　对于集合类型的字段和属性，类型T必须是上述集合类型中的一个。也可以使用这些集合类型的泛型变量(如：Set)。
　　为了返回和设置实例的持久化状态，实例的属性获取方法内可以包含别的业务逻辑，如执行验证。注意：当属性的获取类型为PROPERTY时，持久化运行环境才会执行这些业务逻辑。但在增加的业务逻辑中应该有警告信息。
　　在属性获取方法内抛出的运行时异常会引起事务回滚。当持久化运行时环境使用这些属性获取方法加载或存储实例状态时，如果抛出应用异常，则会引起持久化运行环境回滚事务，并且会抛出封装了应用异常的PersitenceException。
　　实体的子类可以覆盖它的属性获取方法。然而，兼容性好的应用不需要覆盖应用在父类持久化字段和属性上的O/R影射元数据。
　　实体类的持久化字段和属性可以是原始类型、java.lang.String、也可以是其他可序列化类型(包括原始类型的封装类型，java.math.BigInteger，java.math.BigDecimal，java.util.Date，java.util.Calendar，java.sql.Date，java.sql.Time，java.sql.Timestamp，用户自定义类型，byte[]，Byte[]，char[]和Character[])、enum、实体类型和/或实体类型的集合、以及嵌套类型。
　　O/R影射元数据可以用来客户化O/R影射、实体状态和实体间关系的加载和存储。
　　2、创建实体实例
　　通过new操作符创建实体实例。当第一次创建实体实例时，这个实例是非持久化的。通过EntityManager的API可以将实例持久化。实体实例的生命周期在以后的文章中描述，在这里我就不再详细讲述了。