斯坦福 IT

JAVA/J2EE, Struts, Spring, Hibernate学习笔记

新帖 💱交易 💰充值
mogusaen

mogusaen

0$(VIP 0)
8,562
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

转贴 spring学习
http://hi.baidu.com/ayongs/blog/item/b971923d9d0d0905bba167e9.html


学习spring的过程，发现主要掌握3个概念，之后再根据实例做一个小程序，就基本入门了。
三个概念分别为AOP，IoC，和DI。

1、IoC(Inversion of control )反转控制
先看IoC的概念。IoC，Inversion of Control，控制反转[1]， 其原理是基于OO设计 原则的The Hollywood Principle：Don't call us, we'll call you。 也就是说，所有的组件[2]都 是被动的（Passive）， 所有的组件初始化和调用都由容器负责。组件处在一个容器当中，由容器负责管理。

然看举个例子看看IoC在Spring框架里是怎么实现的。所谓IoC就是一个用XML来定义生成对象的模式，我们看看如果来使用的。
要说明IoC模 式最好的方法是使用代码。下边是一段正常的代码。
class ClassA...
public String aMethod(String arg){
String result = instanceOfClassB.bMethod();
do something;
return result;
}
在上边的代码里，我们要解决的问题是：ClassA如何获得ClassB的实例？一个最直接的方法是在aMethod里声明：
IClassB instanceOfClassB = new ClassB();
这里使用了一个接口IClassB。
问题是，如果出现这样的情况：继续使用ClassA，但要求用IClassB的另一个实现ClassB2代替ClassB呢？更概括一点说：ClassA怎样才能找到IClassB的具体实现？很明显，上述代码增加ClassA和ClassB的耦合度，以致于无法在不修改ClassA的情况下变更IClassB的具体实现。
IoC模 式就是用于解决这样的问题。当然，还有其他的方法，比如Service Locator模式，但现在我们只关注IoC。如前所述，IoC容器负责初始化组件（如IClassB），并将实例交给使用者。使用代码或配置文件以 声明的方式将接口与实例关联起来，IoC容 器负责进行实际的调用处理。对于调用者，只需要关注接口就行了。
根据实例传入方式的不同，IoC分为type 1 IoC（接口注入[3]）、type 2 IoC（设值方法注入）和type 3 IoC（构造子注入）。分别用代码说明如下：
type 1 IoC（接口注入）
public interface GetClassB {
void getClassB(IClassB instanceOfClassB);
}

class ClassA implements GetClassB…
IClassB instanceOfClassB;
void getClassB(IClassB instanceOfClassB) {
this.instanceOfClassB = instanceOfClassB;
}
type 2 IoC（设值方法注入）
class ClassA...
IClassB instanceOfClassB;
public void setFinder(IClassB instanceOfClassB) {
this.instanceOfClassB = instanceOfClassB;
}
type 3 IoC（构造子注入）
class ClassA…
ClassB instanceOfClassB;
public classA(IClassB instanceOfClassB) {
this. instanceOfClassB = instanceOfClassB;
}
　　Spring使用的是type 2 IoC。

2、DI(Dependecy Injection)代码注入
根据实例传入方式的不同，IoC分 为type 1 IoC（接 口注入[3]）、type 2 IoC（设值方法注入）和type 3 IoC（构造子注入）。在spring里的是 IOC的第二种，即设置方法注入。具体例子可以查看http://java.chinaitlab.com/Spring/727391.html （Spring 依赖注入原理学习）

3、AOP(Aspect-Oriented Programming)面向方面的编程
要理解AOP的原理，先看这篇文章，文章不长，通过例子通俗易懂的解释了AOP概念的来源以及JAVA的代理机制。http://hi.baidu.com/ayongs/blog/item/1c990a089d75c035e824886e.html
通过上文链接的文章，我们知道了在SPRING的AOP中，IoC功能用来对JAVA动态代理进行改进。来看一个例子。
使用AOP，你可以将处理aspect的代码注入主程序，通常主程序的主要目的并不在于处理这些aspect。AOP可以防止代码混乱。
为了理解AOP如何做到这点，考虑一下记日志的工作。日志本身不太可能是你开发的主程序的主要任务。如果能将“不可见的”、通用的日志代码注入主程序中， 那该多好啊。AOP可以帮助你做到。
Spring framework是很有前途的AOP技术。作为一种非侵略性的，轻型的AOP framework，你无需使用预编译器或其他的元标签，便可以在Java程序中使用它。这意味着开发团队里只需一人要对付AOP framework，其他人还是象往常一样编程。
AOP是很多直觉难以理解的术语的根源。幸运的是，你只要理解三个概念，就可以编写AOP模块。这三个概念是：advice，pointcut和 advisor。advice是你想向别的程序内部不同的地方注入的代码。pointcut定义了需要注入advice的位置，通常是某个特定的类的一个 public方法。advisor是pointcut和advice的装配器，是将advice注入主程序中预定义位置的代码。

既然我们知道了需要使用advisor向主要代码中注入“不可见的”advice，让我们实现一个Spring AOP的例子。在这个例子中，我们将实现一个before advice，这意味着advice的代码在被调用的public方法开始前被执行。以下是这个before advice的实现代码：

代码:
package com.company.springaop.test;

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class TestBeforeAdvice implements MethodBeforeAdvice {

public void before(Method m, Object[] args, Object target)
throws Throwable {
System.out.println("Hello world! (by "
+ this.getClass().getName()
+ ")");
}
}



接口MethodBeforeAdvice只有一个方法before需要实现，它定义了advice的实现。before方法共用三个参数，它们提供了相 当丰富的信息。参数Method m是advice开始后执行的方法。方法名称可以用作判断是否执行代码的条件。Object[] args是传给被调用的public方法的参数数组。当需要记日志时，参数args和被执行方法的名称，都是非常有用的信息。你也可以改变传给m的参数， 但要小心使用这个功能；编写最初主程序的程序员并不知道主程序可能会和传入参数的发生冲突。Object target是执行方法m对象的引用。

在下面的BeanImpl类中，每个public方法调用前，都会执行advice：

代码:
package com.company.springaop.test;

public class BeanImpl implements Bean {

public void theMethod() {
System.out.println(this.getClass().getName()
+ "." + new Exception().getStackTrace()[0].getMethodName()
+ "()"
+ " says HELLO!");
}
}


类BeanImpl实现了下面的接口Bean：

代码:
package com.company.springaop.test;

public interface Bean {
public void theMethod();
}



虽然不是必须使用接口，但面向接口而不是面向实现编程是良好的编程实践，Spring也鼓励这样做。

pointcut和advice通过配置文件来实现，因此，接下来你只需编写主方法的Java代码：
代码:


package com.company.springaop.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {

public static void main(String[] args) {
//Read the configuration file
ApplicationContext ctx
= new FileSystemXmlApplicationContext("springconfig.xml");

//Instantiate an object
Bean x = (Bean) ctx.getBean("bean");

//Execute the public method of the bean (the test)
x.theMethod();
}
}



我们从读入和处理配置文件开始，接下来马上要创建它。这个配置文件将作为粘合程序不同部分的“胶水”。读入和处理配置文件后，我们会得到一个创建工厂 ctx。任何一个Spring管理的对象都必须通过这个工厂来创建。对象通过工厂创建后便可正常使用。
仅仅用配置文件便可把程序的每一部分组装起来。
代码:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<!--CONFIG-->
<bean id="bean" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>com.company.springaop.test.Bean</value>
</property>
<property name="target">
<ref local="beanTarget"/>
</property>
<property name="interceptorNames">
<list>
<value>theAdvisor</value>
</list>
</property>
</bean>

<!--CLASS-->
<bean id="beanTarget" class="com.company.springaop.test.BeanImpl"/>

<!--ADVISOR-->
<!--Note: An advisor assembles pointcut and advice-->
<bean id="theAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref local="theBeforeAdvice"/>
</property>
<property name="pattern">
<value>com\.company\.springaop\.test\.Bean\.theMethod</value>
</property>
</bean>

<!--ADVICE-->
<bean id="theBeforeAdvice" class="com.company.springaop.test.TestBeforeAdvice"/>
</beans>



四个bean定义的次序并不重要。我们现在有了一个advice，一个包含了正则表达式pointcut的advisor，一个主程序类和一个配置好的接 口，通过工厂ctx，这个接口返回自己本身实现的一个引用。

BeanImpl和TestBeforeAdvice都是直接配置。我们用一个唯一的ID创建一个bean元素，并指定了一个实现类。这就是全部的工作。

advisor通过Spring framework提供的一个RegexMethodPointcutAdvisor类来实现。我们用advisor的一个属性来指定它所需的 advice-bean。第二个属性则用正则表达式定义了pointcut，确保良好的性能和易读性。

最后配置的是bean，它可以通过一个工厂来创建。bean的定义看起来比实际上要复杂。bean是ProxyFactoryBean的一个实现，它是 Spring framework的一部分。这个bean的行为通过一下的三个属性来定义：


* 属性proxyInterface定义了接口类。
* 属性target指向本地配置的一个bean，这个bean返回一个接口的实现。
* 属性interceptorNames是唯一允许定义一个值列表的属性。这个列表包含所有需要在beanTarget上执行的advisor。注 意，advisor列表的次序是非常重要的。



Spring工具

虽然你可以手工修改Ant构建脚本，但使用SpringUI（译注：SpringUI现在是Spring framework的一部分，并改名为spring-ide），使用Spring AOP变得很简单，只要点点鼠标即可。你可以把SpringUI安装成Eclipse的一个plug-in。然后，你只需在你的project上右击鼠 标，并选择“add Spring Project Nature”。在project属性中，你可以在“Spring Project”下添加Spring配置文件。在编译前把下面的类库加入project：aopalliance.jar，commons- logging.jar，jakarta-oro-2.0.7.jar和spring.jar。运行程序时你会看到下面的信息：

... (logging information)
Hello world! (by com.company.springaop.test.TestBeforeAdvice)
com.company.springaop.test.BeanImpl.theMethod() says HELLO!


优点和缺点

Spring比起其他的framework更有优势，因为除了AOP以外，它提供了更多别的功能。作为一个轻型framework，它在J2EE 不同的部分都可以发挥作用。因此，即使不想使用Spring AOP，你可能还是想使用Spring。另一个优点是，Spring并不要求开发团队所有的人员都会用它。学习Spring应该从Spring reference的第一页开始。读了本文后，你应该可以更好地理解Spring reference了。Spring唯一的缺点是缺乏更多的文档，但它的mailing list是个很好的补充，而且会不断地出现更多的文档。
 
mogusaen

mogusaen

0$(VIP 0)
8,562
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

（ZT） Spring 依赖注入原理学习

首先我们来看看 Spring 参考文档的 11.2.6. 执行SQL语句 这里有个代码片断:
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class ExecuteAStatement {
private JdbcTemplate jt;
private DataSource dataSource;
public void doExecute() {
jt = new JdbcTemplate(dataSource);
jt.execute("create table mytable (id integer, name varchar(100))");
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
}

这个就是普通的 Java 类, 再参考 11.2.4. DataSource接口, 这里的另一个代码片断:
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("org.hsqldb.jdbcDriver");
dataSource.setUrl("jdbc:hsqldb:hsql://localhost:");
dataSource.setUsername("sa");
dataSource.setPassword("");

我们可以写一个测试类来执行代码:
import org.springframework.jdbc.datasource.DriverManagerDataSource;
public class TestTemplate {
public static void main(String[] args) {
// 新建一个数据源对象
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("org.hsqldb.jdbcDriver");
dataSource.setUrl("jdbc:hsqldb:hsql://localhost:");
dataSource.setUsername("sa");
dataSource.setPassword("");

// 新建一个ExecuteAStatement 对象
ExecuteAStatement eas = new ExecuteAStatement();
// 给执行表达式的对象关联数据源(也就是常说的注入, 通过 JavaBean 的 setXxx 方法关联起来)
eas.setDataSource(dataSource);
// 执行功能代码
eas.doExecute();
}
}

这个代码可以跑通, 就是普通的编程方式, 大家可以去看刚才介绍的文档附近的详细说明.

那么如果用 Spring 来做, 代码会变成这样:

ExecuteAStatement 类代码保持不变, 多了个 beans.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<bean id="userDAO" class="ExecuteAStatement">
<property name="dataSource">
<ref bean="myDataSource" />
</property>
</bean>
<bean id="myDataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>org.hsqldb.jdbcDriver</value>
</property>

<property name="url">
<value>jdbc:hsqldb:hsql://localhost:</value>
</property>

<property name="username">
<value>sa</value>
</property>

<property name="password">
<value></value>
</property>
</bean>
</beans>

测试类:
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
ExecuteAStatement eas =(ExecuteAStatement)context.getBean("userDAO");
// 执行功能代码
eas.doExecute();
}
}

和上面的 TestTemplate 类相比, 就会发现 new DriverManagerDataSource() 这个过程不用我们写了, 运行的时候会发现一切都执行的好好的, 也就是常说的 ExecuteAStatement 的 dataSource 这个属性被注入了.

那么这个过程到底该如何理解呢? Spring 是一个对象池, 可以简化为一个 Map, 存多个主键和对象的映射. 那么 Spring 运行的过程中, 会根据 beans.xml 一步步进行必要的解析工作:

Map springEngine = new HashMap();

OK, 解析到了
<bean id="userDAO" class="ExecuteAStatement">, 发现 bean 定义, 那就新建一个实例存到对象池里吧, 主键就是 userDAO, 值就是对象:
ExecuteAStatement bean1 = new ExecuteAStatement();
springEngine.put("userDAO", bean1);

再往下执行, 发现 property 定义:
<property name="dataSource">

到了这里, 就知道应该调用 bean1.setDataSource(DataSource) 方法了. 可以接着执行, 发现
<ref bean="myDataSource" />, 哦, 这个方法的参数还没有呢, 是个 bean 的引用, 好了, 要调用这个方法, 还是先 new 一个名字为 myDataSource 的 bean2 吧. 就跳到下面寻找 myDataSource 的定义, 找到了:
<bean id="myDataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>org.hsqldb.jdbcDriver</value>
</property>

<property name="url">
<value>jdbc:hsqldb:hsql://localhost:</value>
</property>

<property name="username">
<value>sa</value>
</property>

<property name="password">
<value></value>
</property>
</bean>

像以前一样, 先实例化这个类, 然后看到 property 表情就调用对应的 setXxx() 这样的方法, 相当于下面一段代码:
// 新建一个数据源对象
DriverManagerDataSource bean2 = new DriverManagerDataSource();
bean2.setDriverClassName("org.hsqldb.jdbcDriver");
bean2.setUrl("jdbc:hsqldb:hsql://localhost:");
bean2.setUsername("sa");
bean2.setPassword("");

不是还有个 bean 的 id 名字为 myDataSource 嘛, 那就把它存到对象池里面:
springEngine.put("myDataSource", bean2);
好了, 最后就是把他们两个关联起来了, 通过 ref 里指定的 bean id 名来关联起来:
// 省略类型转换的代码
springEngine.get("userDAO").setDataSource(springEngine.get("myDataSource"));
最后返回给用户的就是一个对象池(一个 Map)了, 所以别人调用的时候, 就发现 springEngine.get("userDAO") 回来的类的 dataSource 属性已经被实例化过了, 这些都是 Spring 幕后工作的代码, 通过反射机制来实现.

所以最后写代码调用:
context.getBean("userDAO") 的时候, 得到的是 ExecuteAStatement, 这时候还有一个 myDataSource, 也可以被调用:
context.getBean("myDataSource"), 得到的是 DriverManagerDataSource.

介绍的过程, 仅供参考. 欢迎大家交流更好的原理介绍文章.
 
最后编辑: 2010-05-21
mogusaen

mogusaen

0$(VIP 0)
8,562
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

（ZT） spring AOP面向切面编程

spring里面有个概念叫aop（面向切面编程），很好很强大又很让人费解，很多开发人员会用并且天天挂在嘴边但是不理解其核心原理，今天周末有空，我 想用一个小系列的文章给大家把aop分析清楚。要理解aop，首先要掌握java中的代理模式。 在日常生活中，会遇到各种各样的中介机构，比如猎头公司，律师事务所，婚姻介绍所，房产公司等。在这些单位工作的人员均可称为代理人。代理人的共同特征是 可以代替委托人去和第三方通信。譬如：律师代替委托人打官司，猎头代替委托人物色人才，红娘 代替委托人寻找对象，房产代理人代替委托人出租房屋。
代理人可以在第三方和委托人之间转发或过滤消息，但是不能取代委托人的任务。譬如你要找女朋友，委托你一要好的哥们去帮你物色，结果被他给物色了。这就不 叫代理。
代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目 标对象之间起到中介的作用。
代理模式一般涉及到的角色有：
抽象角色：声明真实对象和代理对象的共同接口；
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时， 代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。
我们来看个例子：
代码: 
      package com.softeem.aop.staticProxy;
      /**
       * @author leno
       *抽象角色
       */
      public interface IHello {
        String greeting(String who);
      }
      package com.softeem.aop.staticProxy;
      /**
       * @author leno
       *真实角色
       */
      public class HelloImpl implements IHello {
       public String greeting(String who) {
                    System.out.println("greeting method is  invoked.....");
                    return "hello,"+who;
             }
      }
试想一下，如果这时候我们要对问候的业务逻辑方法进行日志记录。我们当然可以这样做：

代码: 
      package com.softeem.aop.staticProxy;
      /**
       * @author leno
       *真实角色
       */
      public class HelloImpl implements IHello {
      private Logger logger =  Logger.getLogger(this.getClass().getName());
       public void log(String message)
       {
        logger.log(Level.INFO, message);
       }
       public String greeting(String who) {
            log( "starting...");
             System.out.println("greeting method is invoked.....");
            log("stopping...");
             return "hello,"+who;
       }
可问题来了，项目经理发话，不容许修改现存的类的实现。怎么办？这时候我们就要就想到代理模式了。我们再加一个代理类：
代码: 
      静态代理类：
      package com.softeem.aop.staticProxy;
      import java.util.logging.Level;
      import java.util.logging.Logger;
      public class HelloLoggerProxy implements IHello {
       private Logger logger =  Logger.getLogger(this.getClass().getName());
       private IHello helloImpl;
       public HelloLoggerProxy(IHello helloImpl) {
        super();
        this.helloImpl = helloImpl;
       }
       public String greeting(String who) {
        log( "starting...");
        String hello = helloImpl.greeting(who);
        log("stopping...");
        return hello;
       }
       public void log(String message)
       {
        logger.log(Level.INFO, message);
       }
      }
  
     客户端测试代码：
      package com.softeem.aop.staticProxy;
      public class TestStaticProxy {
             public static void main(String[] args) {
                    IHello hello = new HelloLoggerProxy(new  HelloImpl());
                    hello.greeting("leno");
             }
      }
由以上代码可以看出，客户实际需要调用的是HelloImpl类的greeting()方法，现在用HelloLoggerProxy来代理 HelloImpl类，同样达到目的，同时还在方法调用的前后都做了日志记录。这就是静态代理。
但是，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实色必须对应角一个 代理角色，如果大量使用会导致类的急剧膨胀；而且，如果项目中要做日志的类有100个，每个类里面有100个方法。重复代码就太可怕了。有人说，不怕，我 就一愚公。好，有天项目经理突然要求修改做日志的方式，你再看看这些方法，估计撞墙的心都有了。那怎么办？我们就改用动态代理。
JDK1.3以后提供了动态代理的支持，程序员通过实现java.lang.reflect.InvocationHandler接口提供一个执行处理 器，然后通过java.lang.reflect.Proxy得到一个代理对象，通过这个代理对象来执行商业方法,在商业方法被调用的同时，执行处理器会 被自动调用。

代码: 
      动态代理类：
      package com.softeem.aop.dynamicProxy;
      import java.lang.reflect.InvocationHandler;
      import java.lang.reflect.Method;
      import java.lang.reflect.Proxy;
      import java.util.logging.Level;
      import java.util.logging.Logger;
      public class DynamicLoggerProxy implements InvocationHandler {
             private Logger logger =  Logger.getLogger(this.getClass().getName());
             private Object delegate;
             @SuppressWarnings("unchecked")
           public Object bind(Object delegate)
             {
                    this.delegate = delegate;
                    Class cls = delegate.getClass();
                    return  Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), this);
             }
             public Object invoke(Object o, Method method, Object[]  args)
                           throws Throwable {
                    log( "starting...");
                    Object obj = method.invoke(delegate, args);
                    log("stopping...");
                    return null;
             }
             public void log(String message)
             {
                    logger.log(Level.INFO, message);
             }
      }
  
     客户端测试代码：
      package com.softeem.aop.dynamicProxy;
      public class TestDynamicProxy {
             public static void main(String[] args) {
                    IHello hello = (IHello) new  DynamicLoggerProxy().bind(new HelloImpl());
                    hello.greeting("leno");
             }
      }
大家看到，一个动态代理类就代替了无数个静态代理类。一劳永逸。这里涉及到一些java反射的知识，我会在以后单独讲述。
java的动态代理非常实用和强大，可它有一个前提，需要我们的处理业务逻辑的类必须至少实现一个接口，虽然面向接口编程是
需要提倡的，但如果我们有些现存的类就是没有实现接口，那如何代理呢？这就需要CGLIB的帮助了。继续改进我们的代码：
没有实现任何接口的类：

代码: 
      package com.softeem.aop.cglibProxy;
      public class Hello{
             public void greeting(String who) {
                    System.out.println("hello,"+who);
             }
      }
      CGLIB代理类：
      package com.softeem.aop.cglibProxy;
      import java.lang.reflect.Method;
      import java.util.logging.Level;
      import java.util.logging.Logger;
      import net.sf.cglib.proxy.Enhancer;
      import net.sf.cglib.proxy.MethodInterceptor;
      import net.sf.cglib.proxy.MethodProxy;
      public class CGLIBLoggerProxy implements MethodInterceptor {
             private final Logger logger =  Logger.getLogger(this.getClass().getName());
             public Object bind(Object delegate)
             {
                    Enhancer enhancer = new Enhancer();
                    enhancer.setCallback(this);
                    enhancer.setSuperclass(delegate.getClass());
                    return enhancer.create();
             }
             public Object intercept(Object o, Method method, Object[]  args,
                           MethodProxy proxy) throws Throwable {
                    log( "starting...");
                    proxy.invokeSuper(o, args);
                    log("stopping...");
                    return null;
             }
             public void log(String message)
             {
                    logger.log(Level.INFO,message);
             }
      }
      客户端测试代码：
      package com.softeem.aop.cglibProxy;
      public class TestCGLIBProxy {
             public static void main(String[] args) {
                    Hello hello = (Hello) new  CGLIBLoggerProxy().bind(new Hello());
                    hello.greeting("leno");
             }
      }
好了，有了动态代理和CGLIB，那我们就可以给任何实际的类提供代理了。从而可以在我们的代理类中加入一些与业务逻辑无关的系统级的功能服务，如：日志 记录，事务处理，安全管理等。而且不会影响到我们现有的系统。看起来似乎很完美 了。但是且慢，如果我们的应用中有些需要这些系统级的功能服务，而有些又不需要呢？如果把代码写死了显然达不到我们的要求。怎么办？这时候就要用到一个非 常重要的思想：用配置代替编码。http://java.chinaitlab.com/Spring/751613_2.html
这里就开始运用SPRING的IOC配置了。我们通过SPRING的一个例子看SPRING怎么样通过IOC将JAVA的代理机制变成SPRING的 AOP。http://hi.baidu.com/ayongs/blog/item/b971923d9d0d0905bba167e9.html
 
mogusaen

mogusaen

0$(VIP 0)
8,562
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

（ZT）Spring学习总结

在MVC架 构中,Spring主要完成C层,Sturts主要完成V层,Hibernate主要完成M层,Spring主要解决了对象创建和依赖,让Spring来管理我们对象的创建和依赖,Spring采 用注入(DI)的 方式来实现.

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

1．Spring相对于EJB是非常小的一个框架,并且不依赖于特定的类,是非侵入式的. IoC（控制反转）的概念：本来是由应用程序管理的对象 之间的依赖关系，现在交给了容器管理，这就叫控制反转，即交给了IoC容器，Spring的IoC容 器主要使用DI方 式实现的。不需要主动查找，对象的查找、定位和创建全部由容器管理.


2.Spring提供了面向切面编程(AOP)的丰富支持。


Spring和Struts集成配置:
(1)、spring和struts的 依赖包配置​
* struts​
--拷贝struts和jstl的 依赖包​
--在web.xml文 件中配置ActionServlet​
--提供struts-config.xml文 件​
--提供国际化支持，提供缺省的国际化资源文件​
* spring ​
--拷贝spring相 关依赖包​
--提供spring的 配置文件​

(2)在web.xml文 件中配置ContextLoaderListener,让Web Server在启动的时候将BeanFactory放 到ServletContext中​
<context-param>​
<param-name>contextConfigLocation</param-name>​
<param-value>classpath:applicationContext-*.xml</param-value>​
</context-param>​
<listener>​
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>​
</listener>​

(3)Struts-config.xml文 件中<action>标 签的type属 性需要更改为Spring的 代理Action类：org.springframework.web.struts.DelegatingActionProxy​
代理Action的 作用：取得BeanFactory， 然后到IoC容 器中将本次请求对应的Action取出​

(4)将Action交 给Spring创 建，必须配置业务逻辑对象，注入给Action​
<bean name="/login" class="com.bjpowernode.usermgr.web.actions.LoginAction">​
<property name="userManager" ref="userManager"/>​
</bean>​
* 必须使用name属 性，而且name属 性的值必须和struts-config.xml文 件中<action>标 签的path属 性值一致​
* 必须配置业务逻辑对象​
* 建议将scope设置为prototype， 这样struts的Action将 是线程安全的.

Spring和Hibernate集 成的方法:
(1)声 明式事务配置​
* 配置SessionFactory​
* 配置事务管理器​
* 事务的传播特性​
* 那些类那些方法使用事务​
<!-- 配置SessionFactory -->​
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">​
<property name="configLocation">​
<value>classpath:hibernate.cfg.xml</value>​
</property>​
</bean>​
<!-- 配置事务管理 器 -->​
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">​
<property name="sessionFactory">​
<ref bean="sessionFactory"/>​
</property>​
</bean>​
<!-- 那些类那些方 法使用事务 -->​
<aop:config>​
<aop:pointcut id="allManagerMethod" expression="execution(* com.bjpowernode.usermgr.manager.*.*(..))"/>​
<aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice"/>​
</aop:config>​
<!-- 事务的传播特 性 -->​
<tx:advice id="txAdvice" transaction-manager="transactionManager">​
<tx:attributes>​
<tx:method name="add*" propagation="REQUIRED"/>​
<tx:method name="del*" propagation="REQUIRED"/>​
<tx:method name="modify*" propagation="REQUIRED"/>​
<tx:method name="*" propagation="REQUIRED" read-only="true"/>​
</tx:attributes>​
</tx:advice>

​
(2)编 写业务逻辑方法​
* 继承HibernateDaoSupport类， 使用HibernateTemplate来 持久化，HibernateTemplate是​
Hibernate Session的 轻量级封装​
* 默认情况下运行期异常才会回滚（包括继承了RuntimeException子 类），普通异常是不会滚的​
* 编写业务逻辑方法时，最好将异常一直向上抛出，在表示层 （struts） 处理​
* 关于事务边界的设置，通常设置到业务层，不要添加到Dao上
 
mogusaen

mogusaen

0$(VIP 0)
8,562
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

设计模式(Patterns in Java)
http://www.jdon.com/designpatterns/

A.创建模式
设计模式 之Factory(工厂模式)
使用工厂模式就象使用new一样频繁.2002/10/9更新

设计模式之 Prototype(原型模式)
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

设计模式之Builder
汽车由车轮 方向盘 发动机很多部件组成，同时，将这些部件组装成汽车也是一件复杂的工作，Builder模式就是将这两种情况分开进行。

设计模式之 Singleton(单态模式)
保证一个类只有一个实例,并提供一个访问它的全局访问点 2002/10/9更新

B.结构模式
设计模式 之Facade
可扩展的使用JDBC针对不同的数据库编程,Facade提供了一种灵活的实现.

设计模式之 Proxy
以Jive为例,剖析代理模式在用户级别授权机制上的应用

设计模式之Adapter
使用类再生的两个方式:组合(new)和继承(extends),这个已经在"thinking in java"中提到过.

设计模式之Composite
就是将类用树形结构组合成一个单位.你向别人介绍你是某单位，你是单位中的一个元素，别人和你做买卖，相当于和单位做买卖。文章中还对Jive再进行了剖 析。

设计模式之Decorator
Decorator是个油漆工,给你的东东的外表刷上美丽的颜色.

设计模式之Bridge
将"牛郎织女"分开(本应在一起,分开他们,形成两个接口),在他们之间搭建一个桥(动态的结合)

设计模式之Flyweight
提供Java运行性能,降低小而大量重复的类的开销.

C.行为模式
设计模式之Template
实际上向你介绍了为什么要使用Java 抽象类,该模式原理简单,使用很普遍.

设计模式之Memento
很简单一个模式,就是在内存中保留原来数据的拷贝.

设计模式之Observer
介绍如何使用Java API提供的现成Observer

设计模式之Chain of Responsibility
各司其职的类串成一串,好象击鼓传花,当然如果自己能完成,就不要推委给下一个.

设计模式之Command
什么是将行为封装,Command是最好的说明.

设计模式之 State
状态是编程中经常碰到的实例,将状态对象化,设立状态变换器,便可在 状态中轻松切换.

设计 模式之Strategy
不同算法各自封装,用户端可随意挑选需要的算法.

设计模式之Mediator
Mediator很象十字路口的红绿灯,每个车辆只需和红绿灯交互就可以.

设计模式之 Interpreter
主要用来对语言的分析,应用机会不多.

设计模式之Visitor
访问者在进行访问时,完成一系列实质性操作,而且还可以扩展.

设计模式之Iterator
这个模式已经被整合入Java的Collection.在大多数场合下无需自己制造一个Iterator,只要将对象装入Collection中，直接使 用Iterator进行对象遍历。更多Iterator专题
 
最后编辑: 2010-05-21
mogusaen

mogusaen

0$(VIP 0)
8,562
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

Java SCJP 英语词汇表


Abstract Window Toolkit(AWT) 抽象窗口工具包
Abstraction 抽象
Anonymous class 匿名类
Anonymous inner class 匿名内部类
Application Programming Interface （API）应用程序接口
Array 数组
Attribute 属性
Base class 基类/父类
Byte stream 字节流
Casting 类型转换
Character stream 字符流
Character 字符
Child class 子类
Class 类
Class member 类的成员
Class method 类的方法
Class variable 类变量
Collection interface Collection接口
Constructor 构造方法
Container 容器
Data Definition Language（DDL） 数据定义函数
Data source 数据源
Data Management System(DBMS) 数据库管理系统
Declaration 声明
Derived Class 派生类/子类
Encapsulation 封装
Event 事件
Event source 事件源
Exception 异常
Exception handling 异常处理
Garbage collection 垃圾回收机制
Generalization 一般化，泛化
Graphics User Interface （GUI） 图形用户界面
Identifier 标识符
Inheritance 继承
Inner class 内部类
Instance 实例
Integrated Development Environment （IDE） 继承开发环境
Interface 接口
Java Database Connectivity （JDBC） Java数据库连接
Java Development Kit（JDK） Java开发工具包
Java Foundation Class （JFC） Java基础类
Java Runtime Environment（JRM） Java运行时环境
Java Virtual Machine （JVM） Java虚拟机
Keyword 关键字
Layout manager 布局管理器
Local variable 局部变量
Member 成员
Meta data 元数据
Method 方法
Modifier 修饰符
Multithread 多线程
Object 对象
Object Oriented Programming (OOP) 面向对象编程
Open DataBase Connectivity (ODBC) 开放式数据库连接
Overloaded method 重载方法
Overridden method 重写方法
Package 包
Parent class 父类
Platform independent 跨平台
Polymorphism 多态
Runtime exception 运行时异常
Structured Query Language (SQL) 结构化查询语言
Sub class 子类
Super class 超类/父类
Synchronized method 同步方法
Thread 线程
Uniform Resource Locator （URL） 统一资源定位器
下面的英语词汇是本人准备SCJP所整理的，现在跟大家分享一下：
encapsulation--封装性 break encapsulation 破坏了封装性
duplicate------重复
invoke---------引用
template-------模板
conventions----公约
contract-------合同，契约，规范，缩短 expand or contract---变大与缩小
identifiers----标识符
keywords-------关键字
inheritance----继承
general--------普通
generate-------产生
explicitly-----明确
cohesive-------凝聚力
recommendations建议
adhere---------坚持
tricky --------绝招
spec-----------规格
compose--------组成
enhancement----增强
a set of-------一组
cleverly-------巧妙
internationally国际
currency character货币符号$
curly braces---花括号{}
comma----------逗号，
semicolon------分号；
parentheses----圆括号()
dot------------圆点.
ellipsis-------省略号……
square brackets方括号[]
angle brackets-尖括号<>
postfix--------后缀 也可以用suffix来表示
prefix---------前缀
preceding------先前的
valid----------有效的
inferred-------推断
retrieve ------重新找到，取回
method signatures方法签名
objective------目标, 目的
guarantee------保证
scope----------范围, 机会, 余地
modifiers------修饰词---------access modifiers----访问权限
polymorphically多态
polymorphism---多态性
collectively---全体的，共同的
crucial--------至关紧要
identical------一样的--------almost identical-----差不多
essentially ---本质上
more than------而不是
other than-----除了，不同于
but rather-----而是
anything but---除了……之外的任何东西； 绝不；
regardless-----不管
Variable Argument Lists可变形参列表
clarify--------澄清，阐明
syntax---------语法
Primitive------基本类型
presented------介绍
fragments------片段
compile--------编译 compilable-------可编译的
collision------冲突
duplicates-----副本
three-dimensional array 三维数组
restrict-------约束
i.e.-----------也就是
enclosed-------被附上的，依附于
nuances--------细微差别
concrete class-具体的类，即非abstract类
spot-----------认出，发现
immutable------不可改变的
inheritance----继承
hierarchies----层次
encapsulation--包装，封装
and theses-----形形色色的-----------and graduate theses 形形色色的大学毕业生
dedicated to---献身于
that is，------换句话说
In a nutshell--简单的说
diamond--------钻石，菱形
hint-----------提示，暗示，线索
Overriding-----覆盖-Overloading---重载

overriding method子类中的覆盖方法
overriden method父类中的被覆盖方法
checked exception===RuntimeException
unchecked exception==非runtime exception
pass the buck to推卸责任给……
Covariant Returns协变返回
assign----------赋值
Coupling--------耦合
Cohesion--------结合，聚合
up front--------预先 admit it up front------预先接纳
With respect to 关于
fragments ------片段
respective------各自的
For the most part在极大程序上
decimal----------十进制
octal-------------八进制
hexadecimal ------十六进制
decimal fraction--小数
implicit----------暗示的 explicit-----直接的
Variable Scope----变量作用域

Wrapper Classes---封装类，如Boolean,Chracter
unBoxing------------拆包------autoboxing-------封装包
Likewise----------同样地
eligible----------符合条件 eligible for garbage collection----符合垃圾回收器的条件
emptied-----------耗尽
reclaimed---------回收，再生
boils down to-----归结为
contrary to-------与什么相反
candidates--------考生，候选人
operands----------操作数
Remainder Operator-- 余数
reminder-------------提醒
remainder------------余数
evaluate----------求值
rightmost---------最右边的
ternary operator--三元操作符
Short-Circuit----使……短路
recursion--------递归
mythical---------神话
is out of--------脱离危险
Side Effects-----副作用
So far so good---到现在为止，一直都还很好
backwards and forwards来回地
sets aside-------留出
as if by magic不可思议的
Calendaring------日历
Locale-----------现场
checkered--------多变的
delimiters-------定界符
get away with it-侥幸成功，逃脱处罚
from Within------从……的内部
is subject to----从属于……；受……支配
issued from------由…&hellip[SIZE=+0];产生
In addition to ……also 除了……外，还可以……
alias------------别名
cries out for----迫切需要
be back----------来回
concurrently-----并发的
be in for--------要遭遇^
daemon threads---守护线程,即后台线程
[/SIZE]
 
Cayman.S

Cayman.S

老衲法号乱来
0$(VIP 0)
729
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

我面试过不少人 同胞 西人 阿X 有些面试程序员的经验 希望能对你有帮助

首先IOC以及AOP现在都需要通过annotation inject而不再是通过XML discriptor bind

同理 HBM也是一样 HB的search以及validator很重要 尤其是validator在EE6已经变成了JSR303的规范 同时 HBM与JPA的差异也需要注意

对于HB细节的把握 是体现技术能力的地方比如 看看这个blog http://clarkupdike.blogspot.com/2007/01/hibernate-mappedby-to-superclass.html 里面的应用 如果你用到过这里提及的运用 说明你对于HB的使用达到了一个比较高的水准。如果你以前没用过，也可以借鉴下。

我面试Hibernate方面问题 一般就提3个问题 1个就是这这个OneToMany polymorphism的处理问题 还有一个是如何同时eager load两个OneToMany的collection 第3个就是Hibernate与Cache的运用

关于Hibernate与Cache应用 我还和Gavin King进行过一些讨论 由于工作关系 我和hibernate的core team有着比较紧密地合作 如果你有兴趣 我们可以进一步交流下

Struts作为action base的MVC framework在很长一段时间内占有统治地位 即使现在大量的legacy系统还是沿用这类框架
同样对于Struts细节的把握 也能体现你的Senior程度 比如 "actionForm的reset 在Struts的整个lifeCycle里面有什么作用"

与此同时 Seam (JSF 1.2+ Facelet+RichFaces) 或者JSF 2.0这里event driven的MVC framework在EE5以及EE6(CDI)变成了de facto的WEB标准

能够区别action base/event base的MVC framework也是一个需要关注的地方

RIA也是趋势 Flex结合BlazeDS是个非常组合

SJCP没有任何用处 你有Spring的基础 可以考虑SpringSource的certification http://www.springsource.com/training/certification
这个比较能忽悠人

基本就这些了 看看有哪些可以进一步的
 
K

kfp

0$(VIP 0)
625
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
mogusaen 说:
多谢高手指点。你说的知识点我会注意学习的。
我是一个项目做了4年，看来有很多知识需要更新了。

希望面试的时候不要碰见Cayman。。。
点击展开...
AOP技术是比较成熟了，但是还没有成为主流，一种观点认为，AOP提出了好多新的概念，比如aspect,advice,joint point, product等，但大多数的developers还没有准备好使用它。AOP的在JEE里主要应用于这两个方面：declarative transaction management and securities, 使用AOP后业务代码可以不用考虑transaction and security的细节。所以建议只作为简单了解，不要花太多经历在这上面。

Spring vs JEE5&6
Spring的创始人Rod Johnson是JEE的坚决反对者，认为JEE没有必要这么复杂。这个argument对于J2EE1.4以前的版本，我是举双手赞成的，但是JEE5之后，JEE做了大量的简化，从Spring和Hibernate "unabashfully" copied很多东西过来，所以现在JEE已经不那么复杂了。WEB Service + Session Bean + JPA(Hibernate)应该是主流趋势。 在这种趋势下，Spring可能只能被逼到做Web层的应用了，无法成为业务逻辑层的主流，再加上Spring已经被过度商业化炒作，有谁敢保证哪一天它不会停止开源这种运作模式呢？

其实对于用户来说，最核心的资产还是数据，应用程序可以不断升级换代，但数据就不一样，一旦定型，多个系统可能共享一个数据库系统，是不方便变更的（very difficult for refactoring）。特别是对于mission-critical的系统，数据库是不能shutdown的。

Hibernate vs ERD
对于数据库的设计，到底从传统的数据库设计ERD开始呢，还是从OO设计出发，将一些java classes nominate为entities，直接generate tables呢？
我个人觉得从ERD->Hibernate,这样可能不太OO，但对于建立业务数据的概念模型CDM非常有效，成熟可靠，一些业务规则可以方便的使用比如oracle pl/sql实现，维护也方便。从oo->ERD,则需要处理由one-to-many/many-to-one等出现的polymorphism的mapping问题。总之，两种方式各有利弊,一个实际的系统应该是二者的结合，需要 trade-offs。
 
最后编辑: 2010-05-23
K

kfp

0$(VIP 0)
625
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

Cayman.S 说:
我面试过不少人 同胞 西人 阿X 有些面试程序员的经验 希望能对你有帮助

首先IOC以及AOP现在都需要通过annotation inject而不再是通过XML discriptor bind

同理 HBM也是一样 HB的search以及validator很重要 尤其是validator在EE6已经变成了JSR303的规范 同时 HBM与JPA的差异也需要注意

对于HB细节的把握 是体现技术能力的地方比如 看看这个blog http://clarkupdike.blogspot.com/2007/01/hibernate-mappedby-to-superclass.html 里面的应用 如果你用到过这里提及的运用 说明你对于HB的使用达到了一个比较高的水准。如果你以前没用过，也可以借鉴下。

我面试Hibernate方面问题 一般就提3个问题 1个就是这这个OneToMany polymorphism的处理问题 还有一个是如何同时eager load两个OneToMany的collection 第3个就是Hibernate与Cache的运用

关于Hibernate与Cache应用 我还和Gavin King进行过一些讨论 由于工作关系 我和hibernate的core team有着比较紧密地合作 如果你有兴趣 我们可以进一步交流下

Struts作为action base的MVC framework在很长一段时间内占有统治地位 即使现在大量的legacy系统还是沿用这类框架
同样对于Struts细节的把握 也能体现你的Senior程度 比如 "actionForm的reset 在Struts的整个lifeCycle里面有什么作用"

与此同时 Seam (JSF 1.2+ Facelet+RichFaces) 或者JSF 2.0这里event driven的MVC framework在EE5以及EE6(CDI)变成了de facto的WEB标准

能够区别action base/event base的MVC framework也是一个需要关注的地方

RIA也是趋势 Flex结合BlazeDS是个非常组合

SJCP没有任何用处 你有Spring的基础 可以考虑SpringSource的certification http://www.springsource.com/training/certification
这个比较能忽悠人

基本就这些了 看看有哪些可以进一步的
点击展开...

Hi there Cayman.S,

Normally where and how do you collect the resumes of candidates for your vacant positions? I'm a PR holder but stil in Beijing waiting for the right time to go to Canada. Recently I sent my resumes to Monster and Workopolis, there have been no responses at all.

Hope to see your feedback.
 
Cayman.S

Cayman.S

老衲法号乱来
0$(VIP 0)
729
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

kfp 说:
AOP技术是比较成熟了，但是还没有成为主流，所以建议只作为简单了解，不要花太多经历在这上面。
点击展开...

EE5以及EE6大量整合了AOP的思想 所以花太多经历在这上面的确不值得，但是 仍然要求对EE5以及EE6有全面的掌握 才能融会贯通。

kfp 说:
WEB Service + Session Bean + JPA(Hibernate)应该是主流趋势。 在这种趋势下，Spring可能只能被逼到做Web层的应用了，无法成为业务逻辑层的主流，再加上Spring已经被过度商业化炒作。
点击展开...
我不看好Spring 我看好Seam/Weld或者EE6的CDI 我也看好Flex+BlazeDS

kfp 说:
Hibernate vs ERD
两种方式各有利弊,一个实际的系统应该是二者的结合，需要 trade-offs。
点击展开...

我爱Hibernate
 
Cayman.S

Cayman.S

老衲法号乱来
0$(VIP 0)
729
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

kfp 说:
Hi there Cayman.S,

Normally where and how do you collect the resumes of candidates for your vacant positions? I'm a PR holder but stil in Beijing waiting for the right time to go to Canada. Recently I sent my resumes to Monster and Workopolis, there have been no responses at all.

Hope to see your feedback.
点击展开...

我们有合作多年的Agent 帮我们pre-screen 一般都能找到一些不错的candidate 我们不直接在Monster或者Workopolis放广告 这样会浪费更多时间

令人满意的resume多数是阿X的 面下来却是非常水 同胞的也有 虽然不多 但是都非常强
 
K

kfp

0$(VIP 0)
625
$0.00
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

Cayman.S 说:
我们有合作多年的Agent 帮我们pre-screen 一般都能找到一些不错的candidate 我们不直接在Monster或者Workopolis放广告 这样会浪费更多时间

令人满意的resume多数是阿X的 面下来却是非常水 同胞的也有 虽然不多 但是都非常强
点击展开...

非常感谢:wdb6:
 
jqhuang

jqhuang

春暖花开
12$(VIP 0,#85)
408
$11.79
$0.00
0.00
0.000
0.0000
最大赞力
0.00
当前赞力
100.00%
回复: JAVA/J2EE, Struts, Spring, Hibernate学习笔记

Cayman.S 说:
我们有合作多年的Agent 帮我们pre-screen 一般都能找到一些不错的candidate 我们不直接在Monster或者Workopolis放广告 这样会浪费更多时间

令人满意的resume多数是阿X的 面下来却是非常水 同胞的也有 虽然不多 但是都非常强
点击展开...
严重同意啊。我们公司的印巴人都比较能吹，脚踏实地干活的真不多。倒是中国人说的少，做的多、好，只是英语没有他们那么溜。
 
最后编辑: 2010-06-05

Similar threads

J
中国话题 2024回国记录
2
39
2024-01-28有新回复
全楼:0.96 wisdom
W
pipilucn
一对一教Java, Python, C++编程
0
2021-11-06有新回复
pipilucn
pipilucn
skythinking
大温哥华 公司招聘java开发人员数名
0
2021-01-05有新回复
skythinking
skythinking
X
求帮忙 42岁2孩妈妈转CS 专业 想找前后端实习
2 3
42
2022-09-18有新回复
全楼:0.85 包包
包包
斯
20年资深Java Developer, 成功转型Dynamics 365/CRM (Architect Lead)学习、工作及技术展示
0
2021-02-24有新回复
斯坦福-IT
斯
0706
希腊语学习总结
2
24
2022-05-05有新赞
全楼:1.90 0706
0706
X
笔记本换屏
19
2022-07-14有新回复
全楼:0.33 reed
reed
云升云起
"中式"英语学习的故事
9
2023-08-24有新赞
全楼:1.01 云升云起
云升云起
B
中国话题 七中全会公告：一致拥戴习总书记登基称帝
6
2022-10-14有新回复
全楼:0.18 TNS
TNS
Max Ma
我们为孩子购买的分红保险如何可让孩子受益终身？
0
2023-11-27有新回复
Max Ma
Max Ma

家园推荐黄页

家园币系统数据

家园币池子报价
0.0097加元
家园币最新成交价
0.0101加元
家园币总发行量
1101666.53家园币
加元现金总量
12044.05加元
家园币总成交量
4098206.67家园币
家园币总成交价值
384692.02加元
池子家园币总量
396336.11家园币
池子加元现金总量
3850.24加元
池子币总量
35214.19
1池子币现价
0.2187加元
池子家园币总手续费
5731.58JYB
池子加元总手续费
595.28加元
入池家园币年化收益率
0.45%
入池加元年化收益率
4.84%
微比特币最新报价
0.090485加元
毫以太币最新报价
4.31918加元
微比特币总量
0.354108BTC
毫以太币总量
0.219250ETH
家园币储备总净值
374,676.79加元
家园币比特币储备
3.4200BTC
家园币以太币储备
15.1ETH
比特币的加元报价
90,485.00加元
以太币的加元报价
4,319.18加元
USDT的加元报价
1.36968加元
交易家园币,比特币...
充值交易资金
交易币种/月度交易量
手续费
家园币
0.1%(0.01%-1%)
加元交易对(比特币等)
1%-2%
USDT交易对(比特币等)
0.1%-0.6%
顶部