语源科技BlogJava-andy-j2ee

JAVA基础巩固加强 enhance day1反射 reflect

安多 — Mon, 07 Nov 2011 12:58:00 GMT

    以前一直只知道有reflect这么一个类是用来反射的，听人家说java中的反射很难，晚上听罢张老师讲的反射这一节的内容，惶然大悟，原来反射就是把Java类中的各种成分映射成相应的java类。
    反射的基础是要掌握Class这个类的，具体Class的类是干什么的，下面是api文档中的解释

api中关于Class类的一段描述

Instances of the class Class represent classes and interfaces in a running Java application. An enum is a kind of class and an annotation is a kind of interface. Every array also belongs to a class that is reflected as a Class object that is shared by all arrays with the same element type and number of dimensions. The primitive Java types (boolean, byte, char, short, int, long, float, and double), and the keyword void are also represented as Class objects.

翻译成中文

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

可以看出Class类就是一个类或者接口对象的一个实例在内存中的字节码，而如何得到一个类的字节码呢？其方法有三：

1         Class extends String> cls1 = str1.getClass();
2         Class<String> cls2 = String.class;
3         Class cls3 = Class.forName("java.lang.String");

    而Class的isPrimitive()方法就是用来判断一个类的字节码是不是9个预定义的class

    接下来是Constructor类，Constructor类代表某个类中的一个构造方法。
   得到某个类所有的构造方法：例子：

Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：
例子：

Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);//获得方法时要用到类型

创建实例对象：

//通常方式：
String str = new String(new StringBuffer("abc"));

//反射方式：
String str = (String)constructor.newInstance(new StringBuffer("abc"));//调用获得的方法时要用到上面相同类型的实例对象

Class.newInstance()方法：
例子：

String obj = (String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

下面是一个Field反射的综合实例

将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。

首先定义一个ReflectPoint的类

1 package com.anduo.day1;
2
3 public class ReflectPoint {
4     private int x;
5     public int y;
6     public String a = "ball";
7     public String b = "basketball";
8     public String c = "hello";
9
10     public ReflectPoint(int x, int y) {
11         super();
12         this.x = x;
13         this.y = y;
14     }
15
16     @Override
17     public String toString() {
18         return "a=" + a + ";b=" + b + ";c=" + c;
19     }
20 }
21

下面的步骤是：先从对象中得到所有为String类型的字段，2：得到Sting字段的值；3：用String类的replace方法代换a字符为b字符；4：把对象的String字段设置为修改完的新String。
齐活儿

1 package com.anduo.day1;
2
3 import java.lang.reflect.Constructor;
4 import java.lang.reflect.Field;
5
6 public class ReflectTest {
7
8
9     public static void main(String[] args) throws Exception {
10
11
12         /**
13          * 成员变量的反射 Field
14          */
15         System.out.println("**成员变量的反射 Field**");
16         ReflectPoint pt1 = new ReflectPoint(1, -1);
17         Field fieldY = pt1.getClass().getField("y");
18         // fieldY 不是对象身上的变量，而是类上，要用它来去对象上字段的值
19         System.out.println("p1 中  y = " + fieldY.get(pt1));
20         Field fieldX = pt1.getClass().getDeclaredField("x");// 获取私有属性字段
21         fieldX.setAccessible(true);// 暴力反射
22         System.out.println("p1 中  x = " + fieldX.get(pt1));
23
24         /**
25          * 将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"
26          */
27         changeStringValue(pt1);
28         System.out.println(pt1);
29     }
30
31     /**
32      * 将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"
33      * @param obj
34      * @throws IllegalArgumentException
35      * @throws IllegalAccessException
36      */
37     private static void changeStringValue(Object obj) throws IllegalArgumentException, IllegalAccessException {
38         Field[] fields = obj.getClass().getFields();
39         for (Field field : fields) {
40             // if(field.getType().equals(String.class))
41             if (field.getType() == String.class) {
42                 String oldValue = (String) field.get(obj);
43                 String newValue = oldValue.replace('a', 'b');
44                 field.set(obj, newValue);
45             }
46         }
47     }
48
49 }
50

结果如下

**成员变量的反射 Field**
p1 中 y = -1
p1 中 x = 1
a=bbll;b=bbsketbbll;c=hello

综上可以看出，其实反射也没多难，人家那些写框架的也不就是用了些反射吗？把配置文件中的东西读出来，然后再调用下面的类去做应该做的事情，当然这个过程就用到了反射了。

安多 2011-11-07 20:58 发表评论

JAVA基础巩固加强 enhance day1

安多 — Mon, 07 Nov 2011 10:52:00 GMT

    最近忙着找工作，可是总是到最后面试完了就没信儿了。哎，你说找个如意的工作就这么难吗？自己感觉实力还是不错的，也有实际的开发经验啊。好多公司打电话第一句话就问，你可不可马上上班，晕，我还没毕业呢？大学生活还没过完。我总觉得大学的最后生活是在幸福中度过的，可是到现在，出了每天跑吉大招聘会之外，基本没别的干的。可能也累了吧，在做完那个派出所的系统后，感觉自己很久没有动手写过代码了，所以为了练练手，同时也为找个"好“工作加些筹码。从今天开始就开始看张老师讲得java基础提高了。
    今天主要是听了JDK1.5的几个新特性，比如静态导入（import static ****）、增强for循环、自动装箱和拆箱-->中间又提到了享元模式。接着就是我以前很少接触的枚举了，在我学的时候根本就没把枚举当回事，因为我在开发的时候很少写自己的enum，大多是用JDK自己写好了的enum 。看了张老师的视频之后才认识到枚举真正的作用和用法，还巩固了一下inner class 。以及如何在定义带有一个抽象方法的枚举。
    下面是今天听课时候自己记的笔记：

1:eclipse 日常用法
2：import static 静态导入与常规导入 import
3:可变参数 overload 和 override 的区别（面试经常考，我就经常遇到）
4:overload重载
override重写
5:增强for循环
for(type 变量：集合变量名){.....}
6:自动装箱和拆箱
       装箱把一个基本数据类型转换为一个引用类型如 Integer i = 3
       拆箱
7:基本数据的缓存
8:享元模式有很多相似的数据，他们有很多的共同点（内部属性），然后，把它变成一个对象，然后把不同的属性作为方法的参数传入（外部属性）
9：枚举:枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。
       枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。
10:采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。
11:枚举的中定义的其他信息必须定义元素列表
12:枚举只有一个成员时，就可以作为一种单例的实现方式

13:class Class--->代表一类事物
   Class cls1 = 字节码1 如 Class cls = String.class;
   Person p1 = new Person();
   Class cls2 = Person.class; // 或者 p1.getClass();
   Class.forName("java.lang.String");//返回字节码 JVM中有\没有

   9个预定义class 八个基本类型 + void
   There are nine predefined Class objects to represent the eight primitive types and void.

下面是今天重点学习的一些代码

1 package com.anduo.day1;
2
3 public class EnumTest {
4
5     /**
6      * @param args
7      */
8     public static void main(String[] args) {
9         // int weekDay = 0;
10         // WeekDay day = WeekDay.Fri;
11         WeekDays day = WeekDays.SUN;
12         System.out.println(day.toString());
13         System.out.println(day.nextDay());
14
15         WeekDay day2 = WeekDay.FRI;
16
17         System.out.println(day2.name());
18
19         WeekDay[] days = WeekDay.values();
20         for (WeekDay weekDay : days) {
21             System.out.println(weekDay);
22         }
23
24         System.out.println("--------------------");
25
26         System.out.println(TrafficLamp.RED.nextLamp().time);
27
28     }
29
30     /**
31      * 枚举的一个对象就相当与一个对象
32      *
33      * @author anduo date:2011-11-7--下午03:01:58
34      */
35     public enum WeekDay {
36         /*
37          * SUN(1)调用的是带有参数的构造方法 SUN 调用的是无参构造方法
38          */
39         SUN(1), MON(2), TUE, WED, THI, FRI, SAT;
40         private WeekDay() {
41             System.out.println("first");
42         }
43
44         private WeekDay(int day) {
45             System.out.println("second");
46         }
47     }
48
49     /**
50      * 带有抽象方法的枚举
51      *
52      * @author anduo
53      *
54      * date:2011-11-7--下午05:38:22
55      */
56     public enum TrafficLamp {
57         RED(30) {
58             @Override
59             public TrafficLamp nextLamp() {
60                 return GREEN;
61             }
62         },
63         GREEN(35) {
64             @Override
65             public TrafficLamp nextLamp() {
66                 return YELLOW;
67             }
68         },
69         YELLOW(5) {
70             @Override
71             public TrafficLamp nextLamp() {
72                 return RED;
73             }
74         };
75         public abstract TrafficLamp nextLamp();
76
77         private int time;
78
79         private TrafficLamp(int time) {
80             this.time = time;
81         }
82     }
83
84 }
85

张老师的课讲得确实好，不敢说自己的境界又提高了多少，但是我可以可定的是以前有写疑问的地方，现在明白了不少。比如：

1 package com.anduo.day1;
2
3 public class AutoBox {
4
5     /**
6      * @param args
7      */
8     public static void main(String[] args) {
9         Integer iObj = 3;// 装箱以前的用法是 new Integer(3)
10
11         System.out.println(iObj + 13);
12
13         Integer i1 = 12;
14         Integer i2 = 12;
15         //在-128~127之间的时候将他们缓存起来当在定义一个对象的时候到缓存池里来查找
16         //如果有就直接引用该对象
17         //而不在上边这个区间的时候就需要建立各自的对象
18         //设计模式是享元模式
19
20         System.out.println(i1 == i2);
21
22
23     }
24
25 }
26

这个问题以前有寝室的问我，我也不知道怎么回答，找google老师，查了很久还是没有得到一个正确的解答，今天总算可以给人家一个满意的答案了。
其实我关注了老师的讲课，我发现如果加上一下发图的说明的过程会更加清晰地解决我们的有些问题。第二点，要掌握一种学习能力，做为一名程序员，企业看重的就是你的学习能力。因为软件这一行的更新速度是最快的，千万不能落后，所以我们做程序员的要天天学习，这样才可以跟着时代的步伐。当然，知识你是学不完了，只要有很强的学习能力，那么不管任何技术都是可以很快拿下的。

安多 2011-11-07 18:52 发表评论

面向对象分析设计—初见OOA && OOD

安多 — Sun, 06 Nov 2011 11:26:00 GMT

     对于一个想要提升自己编程能力的人，是一定要理解OOA和OOD的
     解释一下OOA 即是：Object-oriented analyse；OOD即为：Object-oriented design。面向对象分析、面向对象设计。
     OOA到底解决的是什么呢？说明白一点就是到底OOA是个什么意思，我个人的理解是：分析就是理解客户的需求，知道客户要我们完成什么样的东西。分析问题也是程序设计的第一步，如果第一步走错了，那后边就彻底没戏了。所以分析问题，弄明白客户到底需要什么，这才是OOA，也就想做需求分析一样。
     说完OOA，那OOD到底又是怎么回事呢？所谓OOD就是一个设计的过程，有了OOA，了解了客户的需求后，我们就可以用我们聪明的大脑来为客户设计出满足他们需求的东西了。对于软件开发来说就是来做系统设计。这个过程是个缓慢的过程，需要你大量的代码量才可以做到，虽然我们现在不可以做什么设计。但是我们要向那个方向努力才是，总不能一直停留在一个代码工人的阶段。

安多 2011-11-06 19:26 发表评论

classpath、path、JAVA_HOME的作用

安多 — Sat, 05 Nov 2011 06:13:00 GMT

CLASSPATH是什么？它的作用是什么？

它是javac编译器的一个环境变量。

它的作用与import、package关键字有关。

当你写下improt java.util.*时，编译器面对import关键字时，就知道你要引入java.util这个package中的类；但是编译器如何知道你把这个package放在哪里了呢？所以你首先得告诉编译器这个package的所在位置；如何告诉它呢？就是设置CLASSPATH啦 :) 如果java.util这个package在c:\jdk\ 目录下，你得把c:\jdk\这个路径设置到CLASSPATH中去！当编译器面对import java.util.*这个语句时，它先会查找CLASSPATH所指定的目录，并检视子目录java\util是否存在，然后找出名称吻合的已编译文件（.class文件）。如果没有找到就会报错！

CLASSPATH有点像c\c++编译器中的INCLUDE路径的设置哦，是不是？当c\c++编译器遇到include 这样的语句，它是如何运作的？哦，其实道理都差不多！搜索INCLUDE路径，检视文件！

当你自己开发一个package时，然后想要用这个package中的类；自然，你也得把这个package所在的目录设置到CLASSPATH中去！

CLASSPATH的设定，对JAVA的初学者而言是一件棘手的事。所以Sun让JAVA2的JDK更聪明一些。你会发现，在你安装之后，即使完全没有设定CLASSPATH，你仍然能够编译基本的JAVA程序，并且加以执行。

.....................................................................................................................................................

1. PATH环境变量。作用是指定命令搜索路径，在命令行下面执行命令如javac编译java程序时，它会到PATH变量所指定的路径中查找看是否能找到相应的命令程序。我们需要把jdk安装目录下的bin目录增加到现有的PATH变量中，bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好PATH变量后，就可以在任何目录下执行javac/java等工具了。

2. CLASSPATH环境变量。作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPATH来寻找类的。我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。

3. JAVA_HOME环境变量。它指向jdk的安装目录，Eclipse/NetBeans/Tomcat等软件就是通过搜索JAVA_HOME变量来找到并使用安装好的jdk。

在windows桌面上右击“我的电脑” —> “属性” —> “高级” —> “环境变量”，在“系统变量”里我们可以看到系统的各个环境变量的值。双击某个变量名可以修改变量值，变量值之间用“;”隔开。我们还可以“新建”原先没有的变量。与jdk有关的有3个环境变量；“java_home”，“path”，“classpath”。我的系统中“path”变量已经存在，可以直接添加新值（其它变量值不要动，防止其它程序运行异常），其它两个变量需要新建。

“java_home”，设置jdk的安装路径，比如“e:\java\jdk1.5”，以下简称“%java_home%”。

“path”，设置jdk中各个程序的路径，“%java_home%\bin;%java_home%\jre\bin;”

“classpath”，设置java各个类的路径，“.;%java_home%\lib;%java_home%\lib\tools.jar”。前面的“.”不可少，它代表了我们为自己的java类建立的工作路径，其它的是jdk自带的标准类库路径。

设置好环境变量后按“确定”退出。按“win”+“r”键进入“运行”窗口，运行“cmd”进入DOS窗口，在输入“javac”后回车，如果有显示java的帮助信息，就说明环境变量设置成功。

classpath= ".;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar"

java_home = "C:\Program Files\Java\jdk1.5.0"

path ="%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin "

安多 2011-11-05 14:13 发表评论

排序算法总结

安多 — Fri, 07 Oct 2011 12:34:00 GMT

摘要: 1 package com.anduo.sort;刚刚在大鱼的博客上看到关于排序算法的文章，自己就做了下小实验，代码就是自己copy大鱼的了。谢谢大鱼了。首先建好一个排序类，我就命名为Sort了Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.Code... 阅读全文

安多 2011-10-07 20:34 发表评论

Spring-AOP底层原理-JDK动态代理---转载

安多 — Fri, 07 Oct 2011 11:29:00 GMT

原文http://blog.zdnet.com.cn/html/90/289390-838716.htmlJDK动态代理
  1 package com.baobaotao.proxy; 在JDK 1.3以后提供了动态代理的技术，允许开发者在运行期创建接口的代理实例。在Sun刚推出动态代理时，还很难想象它有多大的实际用途，现在我们终于发现动态代理是实现AOP的绝好底层技术。
    JDK的动态代理主要涉及到java.lang.reflect包中的两个类：Proxy和InvocationHandler。其中InvocationHandler是一个接口，可以通过实现该接口定义横切逻辑，在并通过反射机制调用目标类的代码，动态将横切逻辑和业务逻辑编织在一起。
   而Proxy为InvocationHandler实现类动态创建一个符合某一接口的代理实例。这样讲一定很抽象，我们马上着手动用Proxy和InvocationHandler这两个魔法戒对上一节中的性能监视代码进行AOP式的改造。
    首先，我们从业务类ForumServiceImpl 中删除性能监视的横切代码，使ForumServiceImpl只负责具体的业务逻辑，如所示：
代码清单 5 ForumServiceImpl：移除性能监视横切代码

2
3 public class ForumServiceImpl implements ForumService {
4
5  public void removeTopic(int topicId) {
6          ①
7   System.out.println("模拟删除Topic记录:"+topicId);
8   try {
9    Thread.currentThread().sleep(20);
10   } catch (Exception e) {
11    throw new RuntimeException(e);
12   }
13    ②
14  }
15  public void removeForum(int forumId) {
16          ①
17   System.out.println("模拟删除Forum记录:"+forumId);
18   try {
19    Thread.currentThread().sleep(40);
20   } catch (Exception e) {
21    throw new RuntimeException(e);
22   }
23          ②
24  }
25 }

  在代码清单 5中的①和②处，原来的性能监视代码被移除了，我们只保留了真正的业务逻辑。
    从业务类中移除的横切代码当然还得找到一个寄居之所，InvocationHandler就是横切代码的家园乐土，我们将性能监视的代码安置在PerformaceHandler中，如代码清单 6所示：
代码清单 6 PerformaceHandler 1 package com.baobaotao.proxy;

2 import java.lang.reflect.InvocationHandler;
3 import java.lang.reflect.Method;
4
5 public class PerformaceHandler implements InvocationHandler {
6     private Object target;
7  public PerformaceHandler(Object target){//①target为目标的业务类
8   this.target = target;
9  }
10  public Object invoke(Object proxy, Method method, Object[] args)
11    throws Throwable {
12   PerformanceMonitor.begin(target.getClass().getName()+"."+ method.getName());
13   Object bj = method.invoke(target, args);//②通过反射方法调用目标业务类的业务方法
14   PerformanceMonitor.end();
15   return obj;
16  }
17 }

粗体部分的代码为性能监视的横切代码，我们发现，横切代码只出现一次，而不是原来那样星洒各处。大家注意②处的method.invoke()，该语句通过反射的机制调用目标对象的方法，这样InvocationHandler的invoke(Object proxy, Method method, Object[] args)方法就将横切代码和目标业务类代码编织到一起了，所以我们可以将InvocationHandler看成是业务逻辑和横切逻辑的编织器。下面，我们对这段代码做进一步的说明。
首先，我们实现InvocationHandler接口，该接口定义了一个 invoke(Object proxy, Method method, Object[] args)的方法，proxy是代理实例，一般不会用到；method是代理实例上的方法，通过它可以发起对目标类的反射调用；args是通过代理类传入的方法参数，在反射调用时使用。
    此外，我们在构造函数里通过target传入真实的目标对象，如①处所示，在接口方法invoke(Object proxy, Method method, Object[] args)里，将目标类实例传给method.invoke()方法，通过反射调用目标类方法，如②所示。
    下面，我们通过Proxy结合PerformaceHandler创建ForumService接口的代理实例，如代码清单 7所示：
代码清单 7 TestForumService：创建代理实例 1 package com.baobaotao.proxy;

2 import java.lang.reflect.Proxy;
3 public class TestForumService {
4  public static void main(String[] args) {
5   ForumService target = new ForumServiceImpl();//①目标业务类
6 //② 将目标业务类和横切代码编织到一起
7   PerformaceHandler handler = new PerformaceHandler(target);
8          //③为编织了目标业务类逻辑和性能监视横切逻辑的handler创建代理类
9   ForumService proxy = (ForumService) Proxy.newProxyInstance(
10 target.getClass().getClassLoader(),
11     target.getClass().getInterfaces(),
12  handler);
13          //④ 操作代理实例
14   proxy.removeForum(10);
15   proxy.removeTopic(1012);
16  }
17 }

上面的代码完成了业务类代码和横切代码编织和接口代理实例生成的工作，其中在②处，我们将ForumService实例编织为一个包含性能监视逻辑的PerformaceHandler实例，然后在③处，通过Proxy的静态方法newProxyInstance()为融合了业务类逻辑和性能监视逻辑的handler创建一个ForumService接口的代理实例，该方法的第一个入参为类加载器，第二个入参为创建的代理实例所要实现的一组接口，第三个参数是整合了业务逻辑和横切逻辑的编织器对象。
按照③处的设置方式，这个代理实例就实现了目标业务类的所有接口，也即ForumServiceImpl的ForumService接口。这样，我们就可以按照调用ForumService接口的实例相同的方式调用代理实例，如④所示。运行以上的代码，输出以下的信息：
begin monitor

模拟删除Forum记录:10
end monitor
com.baobaotao.proxy.ForumServiceImpl.removeForum花费47毫秒。

begin monitor
模拟删除Topic记录:1012
end monitor
com.baobaotao.proxy.ForumServiceImpl.removeTopic花费26毫秒。

我们发现，程序的运行效果和直接在业务类中编写性能监视逻辑的效果一致，但是在这里，原来分散的横切逻辑代码已经被我们抽取到PerformaceHandler中。当其它业务类（如UserService、SystemService等）的业务方法也需要使用性能监视时，我们只要按照以上的方式，分别为它们创建代理对象就可以了。下面，我们用时序图描述调用关系，进一步代理实例的本质，如图1所示：

图 1代理实例的时序图
我们在上图中特别使用虚线阴影的方式对通过代理器创建的ForumService实例进行凸显，该实例内部利用PerformaceHandler整合横切逻辑和业务逻辑。调用者调用代理对象的的removeForum()和removeTopic()方法时，上图的内部调用时序清晰地告诉了我们实际上所发生的一切。

安多 2011-10-07 19:29 发表评论

Hibernate学习总结002-IdGenerator

安多 — Fri, 07 Oct 2011 01:27:00 GMT

摘要: 首先来看一下如何使用JPA标准定义一个Hibernate的POJO对象Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 package com.andu... 阅读全文

安多 2011-10-07 09:27 发表评论

Hibernate学习总结001-hibernate概述

安多 — Thu, 06 Oct 2011 13:35:00 GMT

        说到hibernate，英文意思：冬眠。给我印象最深的是孙文琴老师的那本hibernate深入详解分页上的那句话"let you java object hibernate in the relation database"。其实后边学完了再回头看这句话的时候就发现其实这句话说的很形象，它深刻的反映了hibernate在软件开发中的重要作用：ORM（object relation mapping 对象关系映射），那么要学习hibernate首先需要了解的就是ORM。
        所谓ORM的解释，可以从维基百科中查到：
        对象关系映射（Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程式设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。如今已有很多免费和收费的ORM产品，而有些程序员更倾向于创建自己的的ORM工具。

面向对象是从软件工程基本原则（如耦合、聚合、封装）的基础上发展起来的，而关系数据库则是从数学理论发展而来的，两套理论存在显著的区别。为了解决这个不匹配的现象，对象关系映射技术应运而生。

简单的说：ORM相当于中继数据。具体到产品上，例如下边的ADO.NET Entity Framework。DLINQ中实体类的属性[Table]就算是一种中继数据。

对象关系映射成功运用在不同的面向对象持久层产品中，如：Torque，OJB，Hibernate，TopLink，Castor JDO，TJDO，Active Record，NHibernate，ADO.NET Entity Framework 等。
        以上是维基百科中解释。所的很官僚，就是说的我们大家一般的人不太能理解。我个人的理解就是：对我们这些对JDBC常用操作非常厌倦的人来了个封装，然后给我们各种常用的接口，而且让我们感觉不到我们在操纵数据库，而只是在调人家给的接口，这无形中让我们感觉到很舒服，很惬意。
        hibernate同样是ORM工具，那么它给我们提供了那些接口呢？让我列举几个：
        Session、负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。)。
        SessionFactory、负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式
        Transaction、负责事务相关的操作。它是可选的，开发人员也可以设计编写自己的底层事务处理代码
        Query、Query和Criteria接口负责执行各种数据库查询。它可以使用HQL语言或SQL语句两种表达方式
        Configuration、负责配置并启动Hibernate，创建SessionFactory对象。

安多 2011-10-06 21:35 发表评论

JavaSE学习之路-001-指导路线

安多 — Thu, 06 Oct 2011 13:10:00 GMT

看着身边很多朋友盲目的学习java，自己真的很想帮帮他们，所以我觉得我应该把我这个自学者的经验分享给那些还在继续着java无边际学习的朋友们指指路，分享我的那些经验也好，错误也罢。

--------------------写在前面

熟话说，有了目标的前进就不怕没有结果，所以我们首先要明了Java学习的路线
     前几天在网上看到一副java的路线图，觉得很受用，转了下来，让我们先看看图，然后看图说话。

    可能有写朋友看到这么大的一张图会很晕。这么就个java要学这么多了。不是我就学java，吗？为什么还要我去学什么html css jsp 这些都是什么啊？请大家稍安勿躁，且听我慢慢道来。

怎么学java是很多新手的经常问到的问题，现在我就根据网上的一篇博客来简单的介绍一下吧。

首先要明白Java体系设计到得三个方面：J2SE,J2EE,J2ME（KJAVA）。J2SE，Java 2 Platform Standard Edition，我们经常说到的JDK，就主要指的这个，它是三者的基础，属于桌面级应用开发，这部分如果学得好很容易拓展J2EE和J2ME。J2ME，The Micro Edition of the Java 2 Platform。主要用于嵌入式Java，如手机，PDA等等。J2EE，Java 2 Platform，Enterprise Edition，就是所谓的企业级Java，适合企业的大型应用开发。
J2SE：
       新手最初学习的时候先要从J2SE开始学起，所包含的内容主要分为：面向对象概念的理解、Java基本语法的学习，Java桌面图形界面应用程序的开发，掌握常用的Java API等（关键是要学会怎样查阅）。
重点：Java基本语法（循环结构，数据类型，数组，运算符等）、Swing，awt，事件机制、文件输入输出流处理等
难点：面向对象思想的理解（接口、类等）、线程、socket网络编程等
视频教程推荐：孙鑫的Java基础视频教程、张孝祥的Java基础视频教程，讲的都很细，而且这两位老师在教学方面都有很好的经验。
J2EE：
        在学习了J2SE之后，你可以尝试着慢慢过渡到J2EE，当然，学习J2EE海需要很多非JAVA技术的支撑，比如数据库技术，网页编程技术等等，待会我会详细介绍这两方面的内容。J2EE有三个必学的框架，如果你说你学了J2EE，但又不会这三个框架的话，那会让人笑掉大牙，这三个框架分别是Struts、Spring和Hibernate，虽然这三个框架应用很广，但不代表这三个框架就代表了J2EE，J2EE还有很多其他的东西，比如EJB，作为一款重量级（此重量级不是指重量级选手那个意思，此重量级非彼重量级）框架，虽然这个应用慢慢的再被其他框架所取代，但EJB3.0的出现也给它带回一些生机，作为一个分布式应用的框架，也是大家要去学习和了解的知识。
        当然，刚才说到J2EE包含的范围很广，即使我把我所了解的所有技术说出来，也并不能代表J2EE，这是一个很深很广的学问，需要大家以后再工作的时候慢慢去发现了。我所了解的还包括：
JDBC:Java数据库连接对象，基础中的基础，Hibernate也只是对它的封装而已
JNDI: Java 命名与目录接口，J2EE重要规范之一
EJBS: 上面已经提到过了
RMI: 提供远程调用方法的支持，主要用于程序分布式开发
JMS: Java消息服务，中间件技术
JAVA IDL: 提供J2EE平台与CORBA交互能力和互联能力的技术
JTS: 组件事务监视器
JTA: 事务划分的一个技术
JAVAMAIL: Java中的邮件技术
JAF: Java启动框架,没研究过
Log4j，一款日志处理的框架应用
Junit：单元测试的好帮手
freemarker、velocity：两款不错的模板引擎
与Flash的交互Flex：目前很多的SNS应用就是使用到了这个技术
Web services:想知道我们论坛天气预报的效果是怎么做的吗？请关注这个技术
SOA:面向服务架构，未来技术发展的趋势之一
……
        不过前面介绍到得这些都不是J2EE的基础,是属于框架应用级别的.要真正把上面说到的知识掌握好,还是的学习J2EE最核心的东西:JDBC、JSP、servlet和JavaBean,后面三个也是学习SSH的基础(Struts/Spring/Hibernate的简称).鉴于J2EE的内容太过复杂,建议大家最初只学习: JSP, servlet和JavaBean，等这个基础掌握好再把SSH学习了，再对其他J2EE技术有个大致的了解就可以出去找工作了。当然，找工作的前提除了把Java学习好，还会有一些其他的技术也是必须要掌握的。

-_- 我很简单,Java却要求我学这么多复杂的东西。除了这些技术的东西，在这阶段，大家更多的是会接触到比如设计模式的东西，比如工厂模式、桥梁模式、单例模式等等，还要学习建模思想（比如UML建模等等）和软件生命周期等等。这些是升华大家编程思想的手段和途径。
数据库技术:
     数据库几乎是程序中不可或缺的一部分,在整个软件开发中更是占据了重要作用.数据库在整个软件中扮演的是地基的角色,你要修房子,就要先打好地基,你要做软件,就要先设计好的数据库.目前数据库几乎都是关系型数据库,代表的有:
SQL Server,目前最新的好像是2008,我不是很喜欢追赶时髦,用的还是2005,不过也很不错了,在此之前还有2000.
MySQL,最知名的开源数据库之一,我很喜欢它的小巧耐用,学过SQL SERVER数据库再学它,无师自通,易如反掌.
ORACLE.甲骨文公司的产品,大型数据库,正版的一般公司买不起.只有看看了,不过现在Java开发60%都是会使用到这个数据库,再加上现在甲骨文已经把sun公司收购了,JAVA和ORACLE得关系更加暧昧,各位得多花些时间在这上面了.
除了这些，你还应该了解一些桌面应用软件开发用到的数据库，比如说sqlite。你在制作安装程序的时候可以把这个数据库打包进你的安装程序。
网页编程基础:
     网页编程基础要学的内容也比较多,但主要集中在以下这三个技术之上,大家每天看的各种样式的网页都是它们呈现的:
HTML:超文本标记语言
CSS:层叠样式表
Javascript:浏览器客户端脚本语言
现在更是流行各种JavaScript库,比如:Jquery、ExtJs等，你要是会其中的某一个库的使用，找工作so easy。
J2ME：
     如果你在学习了以上技术还不过瘾，可以再学习手机程序的开发，就我个人看来，开发手机程序技术其实蛮简单的，难点在于优化，比如怎么让你写的程序尽量的节约手机资源，“代码诚可贵，手机价更高“，所以不得不比PC机多考虑很多成本和实用性问题。J2ME的学习的话，切忌不要单纯的再模拟器上测试，一定要找真机测试，真机和模拟器的效果之间差别是很大的。更多手机开发技术，有兴趣的朋友可以和我一起探讨。
开发工具：
    开发工具的选择主要还是看大家的习惯，我个人比较喜欢使用eclispe，功能很强大，也很好拓展其他的功能。当让初学你也可以选择JCreator，或者最好就直接用记事本。等你熟悉了Java代码之后，就可以使用JBuilder、eclispe或者netbeans这一类的工具了。

----此文出于http://tieba.baidu.com/f?kz=692446591

安多 2011-10-06 21:10 发表评论

关于爱情的那些

安多 — Sun, 03 Jul 2011 14:16:00 GMT

太爱一个人，你会太在乎他跟谁一起，心里是否有你；太爱一个人，会被他牵着鼻子走，完全不能自己；太爱一个人，会无原则地忍受他，慢慢他习惯被纵容；太爱一个人，他会习惯你对他的好，而忘了自己也应该付出。所以，爱一个人不要爱十分，八分已足够，剩下的两分爱自己

安多 2011-07-03 22:16 发表评论

软件开发的需求分析

安多 — Mon, 27 Jun 2011 07:37:00 GMT

软件开发的第一步是需求分析。对需求的分析、准确理解和把握，对于软件的成功至关重要，过于频繁的需求变更往往导致软件开发陷入“人月神话”的困境。现代软件工程提出的面向对象分析方法给软件需求分析提供了便利。

面向对象分析通常分为三个步骤：

领域分析找出给系统涉及的名词或术语
用户分析找出使用该系统的用户，并明确分类用户需要具备的功能
功能分析分析功能，并对每个功能点进行细化

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

安多 2011-06-27 15:37 发表评论

如何用jdbc连接数据库 java连接数据库的五步

安多 — Thu, 09 Jun 2011 14:18:00 GMT

用JDBC连接数据库

本文用sqlserver2000为例

先简述JDBC连接数据库的五步

1，加载驱动。这里的驱动是根据各个数据的情况有所不同，但是格式一样，一般用

Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

2，创建连接。DriverManager.getConnection(url, userName, password);

参数说明：url 是指连接的地址由五个部分组成协议+服务+IP+端口+资源

（附：几个常用的数据库的默认端口号:

sqlserver 1433

oracle 1523

mysql 3306

）

userName 数据库用户名

password 用户名密码

3，根据sql语句建立statement对象或者是preparedstatement对象

4，操作数据此处分为两类查询和增删改

5，关闭statement和connection对象

下面是一个小小的测试

package com.anduo;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class DBtest {
 public static void main(String[] args) {
  Connection con = null;
  Statement stmt = null;

  try {
   // 第一步 加载驱动
   Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

   // 第二步 创建链接
   String url = "jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=test";
   con = DriverManager.getConnection(url, "sa", "sa");

   // 第三步 创建方式
   stmt = con.createStatement();

   // 第四步 操作数据
   String sql = "insert into student_anduo(student_name,student_sex,student_age) values('user1','male',21)";
   stmt.executeUpdate(sql);
   sql = "select * from student_anduo";
   ResultSet rs = stmt.executeQuery(sql);
   while (rs.next()) {
    System.out.println(rs.getObject(1));
   }

   String sql_d = "drop table student_anduo";
   stmt.executeUpdate(sql_d);

  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (SQLException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } finally {

   // 第五步 关闭
   try {
    if (stmt != null) {
     stmt.close();
     stmt = null;
    }
    if (con != null) {
     con.close();
     con = null;
    }

   } catch (SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }

  }

 }
}

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

安多 2011-06-09 22:18 发表评论

一个Java程序员应该掌握的10项技能

安多 — Wed, 01 Jun 2011 04:25:00 GMT

1、语法：必须比较熟悉，在写代码的时候IDE的编辑器对某一行报错应该能够根据报错信息知道是什么样的语法错误并且知道任何修正。

2、命令：必须熟悉JDK带的一些常用命令及其常用选项，命令至少需要熟悉：appletviewer、 HtmlConverter、jar、 java、javac、javadoc、javap、javaw、native2ascii、serialver，如果这些命令你没有全部使用过，那么你对java实际上还很不了解。

3、工具：必须至少熟练使用一种IDE的开发工具，例如Eclipse、Netbeans、JBuilder、Jdeveloper、IDEA、JCreator或者Workshop，包括进行工程管理、常用选项的设置、插件的安装配置以及进行调试。

4、API：Java的核心API是非常庞大的，但是有一些内容笔者认为是必须熟悉的，否则不可能熟练的运用Java，包括：
◆java.lang包下的80％以上的类的功能的灵活运用。

◆java.util包下的80％以上的类的灵活运用，特别是集合类体系、规则表达式、zip、以及时间、随机数、属性、资源和Timer.

◆java.io包下的60％以上的类的使用，理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合。

◆java.math包下的100％的内容。

◆java.net包下的60％以上的内容，对各个类的功能比较熟悉。

◆java.text包下的60％以上的内容，特别是各种格式化类。

◆熟练运用JDBC. 8）、java.security包下40％以上的内容，如果对于安全没有接触的话根本就不可能掌握java.

◆AWT的基本内容，包括各种组件事件、监听器、布局管理器、常用组件、打印。

◆Swing的基本内容，和AWT的要求类似。

◆XML处理，熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理。

5、测试：必须熟悉使用junit编写测试用例完成代码的自动测试。

6、管理：必须熟悉使用ant完成工程管理的常用任务，例如工程编译、生成javadoc、生成jar、版本控制、自动测试。

7、排错：应该可以根据异常信息比较快速的定位问题的原因和大致位置。

8、思想：必须掌握OOP的主要要求，这样使用Java开发的系统才能是真正的Java系统。

9、规范：编写的代码必须符合流行的编码规范，例如类名首字母大写，成员和方法名首字母小写，方法名的第一个单词一般是动词，包名全部小写等，这样程序的可读性才比较好。

10、博学：掌握J2EE 、Oracle 、WebLogic、Jboss、Spring、Struts、Hibernate 等流行技术，掌握软件架构设计思想、搜索引擎优化、缓存系统设计、网站负载均衡、系统性能调优等实用技术。

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

安多 2011-06-01 12:25 发表评论

css+div 纵向列表

安多 — Sun, 22 May 2011 02:33:00 GMT

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=gb2312" /> <title>3.1纵向列表</title> <link href="3.1.css" mce_href="3.1.css" rel="stylesheet" type="text/css" /> </head> <body> <div id="menue"> <ul> <li><a href="#" mce_href="#">首页</a></li> <li><a href="#" mce_href="#">网页版式布局</a></li> <li><a href="#" mce_href="#">div+css教程</a></li> <li><a href="#" mce_href="#">div+css实例</a></li> <li><a href="#" mce_href="#">常用代码</a></li> <li><a href="#" mce_href="#">站长杂谈</a></li> <li><a href="#" mce_href="#">技术文档</a></li> <li><a href="#" mce_href="#">资源下载</a></li> <li><a href="#" mce_href="#">图片素材</a></li> </ul> </div> </body> </html>

css文件

#menue ul { margin: 0px; padding: 0px; list-style: none; } body { font-family: Verdana, Arial, Helvetica, sans-serif; font-size: 12px; line-height: 1.5; } #menue { border: 1px solid #669900; width: 100px; } #menue ul li { line-height: 26px; background: #eee; padding: 0px 8px; height: 26px; border-bottom: 1px solid #ccc; } a { color: #000000; text-decoration: none; } a:hover { color: #FF0000; }

最终效果：

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

安多 2011-05-22 10:33 发表评论

DIV+CSS学习第一天

安多 — Fri, 20 May 2011 11:08:00 GMT

1 一列固定宽度
2 一列固定宽度居中
3 一列自适应宽度
4 一列自适应宽度居中
5 一列二至多块布局

采用了dreamweaver来开始网页设计，其优点主要有：代码提示，可视化开发环境，完美支持css+div

一列固定宽度

一列固定宽度居中
一列固定宽度居中和一列固定宽度相比，我们要解决的问题就是居中。这里我们用到css的外边距属性：margin。在IE6及以上版本和标准的浏览器当中，当设置一个盒模型的的margin:auto;时，可以让这个盒模型居中。
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=gb2312" /> <mce:style type="text/css"></mce:style><style type="text/css" mce_bogus="1">#layout { height: 300px; width: 400px; background: #99FFcc; margin:auto; }</style> </head></p> <p><body> <div id="layout">此处显示 id "layout" 的内容</div> </body> </html>

一列自适应宽

自适应宽度是相对于浏览器而言，盒模型的宽度随着浏览器宽度的改变而改变。这时要用到宽度的百分比。当一个盒模型不设置宽度时，它默认是相对于浏览器显示的。
这里的选择器类型是新手朋友最容易迷糊的地方，类：是指定义一个class，可以多个对象引用；标签：指对默认的html标签进行重新定义，如可以定义body{margin:0}，意思是将body的外边距设置为0，h2{color:#f00}是将所有h2标签的文字颜色设置为红色；高级它把ID和伪类放到一块了，是一个设置不合理的地方，在cs4版本中已经分开了。ID是以#开始，id只能作用于一个对象，不能作用于多个对象，优先级高于class，这是id和class的区别。
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=gb2312" /> <mce:style type="text/css"></mce:style><style type="text/css" mce_bogus="1">body { margin:0;} #layout { height: 300px; width: 80%; background: #99FFcc; }</style> </head></p> <p><body> <div id="layout">此处显示 id "layout" 的内容</div> </body> </html>

一列自适应宽度居中
同样和固定宽度居中一样，我们只需要设置div的外边距为auto即可实现居中了。

一列二至多块布局
一般的网站整体可以分为上中下结构，即：头部、中间主体、底部。那么我们可以用三个div块来划分，分别给它们起名为：头部（header）、主体（maincontent）、询问（footer）。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=gb2312" /> <mce:style type="text/css"></mce:style><style type="text/css" mce_bogus="1">body { margin:0; padding:0;} #header { margin:5px auto; width:500px; height:80px; background:#9F9;} #main { margin:5px auto; width:500px; height:400px; background:#9FF;} #footer { margin:5px auto; width:500px; height:80px; background:#9f9;}</style> </head></p> <p><body> <div id="header">此处显示 id "header" 的内容</div> <div id="main">此处显示 id "main" 的内容</div> <div id="footer">此处显示 id "footer" 的内容</div> </body> </html>

注意：许多朋友在问：为什么两个相邻的容器中间的间距不是10px，而是5px呢？按照我们正常的理解，认为应该是两个值相加，其实这里是两个合并后取最大值。用css手册中的话说：块级元素的垂直相邻外边距会合并，而行内元素实际上不占上下外边距。行内元素的的左右外边距不会合并。同样地，浮动元素的外边距也不会合并。允许指定负的外边距值，不过使用时要小心

小结

1、CSS可视化生成、格式化
2、CSS缩写

3、CSS语法

如图所示，CSS语法由如下三部分构成，选择器：可以是ID、CLASS或标签；属性和值是用来定义这个物件的某一个特性。如一张桌子的长120cm，宽60cm，套用css的格式为，桌子{长:120cm;宽:60cm;}，这样是不是容易理解。

4、ID和CLASS选择器

id只能在页面中对应一个元素，就像我们的身份证号一样，每个人的都不一样；class为类，可以对应多个元素，比如说一年级三班的学生，它所对应的可能是10个20个学生。

id的优先级高于class，比如说今天三班的学生上体育课，小明留下来打扫卫生。那么三班的学生上体育课这是一个类，而小明打扫卫生这是个id，虽然小明也是三班的学生，但id高于class，所以小明执行打扫卫生的任务。

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

安多 2011-05-20 19:08 发表评论