BlogJava-Exciting IN JAVA WAY-文章分类-Spring Dev

Spring aop

chenguo — Mon, 18 Jun 2007 10:06:00 GMT

AOP正在成为软件开发的下一个圣杯。使用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管理的对象都必须通过这个工厂来创建。对象通过工厂创建后便可正常使用。

仅仅用配置文件便可把程序的每一部分组装起来。

代码:

com.company.springaop.test.Bean

theAdvisor

com\.company\.springaop\.test\.Bean\.theMethod

四个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是个很好的补充，而且会不断地出现更多的文档。

chenguo 2007-06-18 18:06 发表评论

Spring例子JPetStore分析---------3jpetstore的各层之间的关系部分分析

chenguo — Mon, 18 Jun 2007 10:05:00 GMT

下面就jpetstore的账号管理部分，来分析一下jpetstore的各层之间的关系：

1。持久层分析

1.1账号管理的iBatis的xml影射部分如下：

账号管理涉及到四张表：

signon 存放用户名，密码

account, 存放用户的基本信息

profile, 存放用户选择的语言，以及喜爱的商品分类

bannerdata 目前不清楚

http://www.ibatis.com/dtd/sql-map-2.dtd">

《账号信息结果集》

《根据用户名，获得用户信息》

《根据账号，密码，获取账号》

《获取系统用户名列表》

《更新账号信息》

update account set email = #email#, firstname = #firstName#, lastname = #lastName#, status = #status#, addr1 = #address1#, addr2 = #address2:varchar#, city = #city#, state = #state#, zip = #zip#, country = #country#, phone = #phone# where userid = #username#

《增加新账号》

insert into account (email, firstname, lastname, status, addr1, addr2, city, state, zip, country, phone, userid) values (#email#, #firstName#, #lastName#, #status#, #address1#, #address2:varchar#, #city#, #state#, #zip#, #country#, #phone#, #username#)

《更新用户profile表，其中包括用户语言选择，以及喜欢的动物分类

update profile set langpref = #languagePreference#, favcategory = #favouriteCategoryId#, mylistopt = #listOptionAsInt#, banneropt = #bannerOptionAsInt# where userid = #username#

《增加用户profile信息〉

insert into profile (langpref, favcategory, mylistopt, banneropt, userid) values (#languagePreference#, #favouriteCategoryId#, #listOptionAsInt#, #bannerOptionAsInt#, #username#)

〈更新用户密码〉

update signon set password = #password# where username = #username#

〈增加用户名，密码到用户登录表Signon〉

insert into signon (password,username) values (#password#,#username#)

1.2 Account为账号管理的POJO类，AccountDao 为账号管理interface，规定了一系列方法：

public interface AccountDao {

Account getAccount(String username) throws DataAccessException;

Account getAccount(String username, String password) throws DataAccessException;

void insertAccount(Account account) throws DataAccessException;

void updateAccount(Account account) throws DataAccessException;

List getUsernameList() throws DataAccessException;

}

1.3Account interface 实现：

public class SqlMapAccountDao extends SqlMapClientDaoSupport implements AccountDao {

public Account getAccount(String username) throws DataAccessException {
return (Account) getSqlMapClientTemplate().queryForObject("getAccountByUsername", username);
}

根据用户名，密码，获得账号

public Account getAccount(String username, String password) throws DataAccessException {
    Account account = new Account();
    account.setUsername(username);
    account.setPassword(password);
    return (Account) getSqlMapClientTemplate().queryForObject("getAccountByUsernameAndPassword", account);
}

创建账号，需要更新account,signon,profile三张表

public void insertAccount(Account account) throws DataAccessException {
    getSqlMapClientTemplate().insert("insertAccount", account);
    getSqlMapClientTemplate().insert("insertProfile", account);
    getSqlMapClientTemplate().insert("insertSignon", account);
}

更新账号，需要更新account,signon,profile三张表

public void updateAccount(Account account) throws DataAccessException {
    getSqlMapClientTemplate().update("updateAccount", account, 1);
    getSqlMapClientTemplate().update("updateProfile", account, 1);
    if (account.getPassword() != null && account.getPassword().length() > 0) {
      getSqlMapClientTemplate().update("updateSignon", account, 1);
    }
}

《获取系统用户名列表》

public List getUsernameList() throws DataAccessException {
return getSqlMapClientTemplate().queryForList("getUsernameList", null);
}

}

总结：

iBatiｓ持久层使用sql-map-config.xml配置所有ibatis .xml文件

使用dataAccessContext-config.xml配置所有DAO实现

2，持久层和业务逻辑层的耦合，业务逻辑接口中包含了AccountDAO的接口操作

public interface PetStoreFacade {

Account getAccount(String username);

Account getAccount(String username, String password);

void insertAccount(Account account);

void updateAccount(Account account);

List getUsernameList();

。。。。。。。

}

业务逻辑对象PetStoreImpl 实现了对accountDao的再次封装

public class PetStoreImpl implements PetStoreFacade, OrderService {

private AccountDao accountDao;

public Account getAccount(String username) {
return this.accountDao.getAccount(username);
}

public Account getAccount(String username, String password) {
return this.accountDao.getAccount(username, password);
}

public void insertAccount(Account account) {
this.accountDao.insertAccount(account);
}

public void updateAccount(Account account) {
this.accountDao.updateAccount(account);
}

public List getUsernameList() {
return this.accountDao.getUsernameList();
}

。。。。

}

总结：

持久层与业务逻辑层的耦合是在applicationContext.cml中：

为业务逻辑层提供事务管理

    abstract="true">



    PROPAGATION_REQUIRED
    PROPAGATION_REQUIRED
    PROPAGATION_REQUIRED,readOnly

4表示层和业务逻辑层的耦合：

表示层和业务逻辑层的耦合是通过BaseAction来实现的，并通过接口来访问业务逻辑对象：

public abstract class BaseAction extends Action {

private PetStoreFacade petStore;

public void setServlet(ActionServlet actionServlet) {
  super.setServlet(actionServlet);
  if (actionServlet != null) {
   ServletContext servletContext = actionServlet.getServletContext();
   WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
   this.petStore = (PetStoreFacade) wac.getBean("petStore");
  }
}

protected PetStoreFacade getPetStore() {
return petStore;
}

}

所有的系统里面的Action都是从BaseAction派生过来的，而BaseAction的派生类中，提供了对业务逻辑对象
PetStoreFacade 的访问。

chenguo 2007-06-18 18:05 发表评论

分析和学习Spring中的jpetstore用户管理

chenguo — Mon, 18 Jun 2007 10:05:00 GMT

分析和学习Spring中的jpetstore用户管理

存在用户的系统，必然需要用户的登录和认证，今天就通过分析Spring中自带的jpetstore的例子来学习一下如何实现在Spring构架的系统中用户登录。

1、首先从注册用户开始，先看看jpetstore-servlet.xml中关于注册用户的bean定义，从定义命名中就可以看出下面这段就是注册用户的：



    index

1). formView呢？从AccountFormController的构造函数中得到，原来为EditAccountForm；
2). EditoAccountForm.jsp中显得非常乱，其实没有多少难理解的地方，最主要的是这个form既是添加新用户的，又是编辑用户信息的，所以显得有点乱糟糟的。

2、添加好了新用户，接下来看看如何登录，在jpetstore-servlet中发现这两个相关bean定义，如下：



    SignonForm

1). 第二个bean是在运行时用户输入用户名和密码的form，叫做SignonForm，对于这个 ParameterizableViewController，用文档里的话说这是最简单的Controller，其作用就是在运行中指向 Controller而不是直接指向jsp文件，仅此而已。
2). SignonForm.jsp，里面就是一个简单的form，其action就是第一个bean，即/shop/signon.do，最需要注意的是 signonForwardAction，其主要作用是forward到需要输入用户名和密码的那个页面上去，这个变量哪里来的呢？看看下面：















原来，上面的signonInterceptor实现了preHandle，因此在请求上面的map页面时，首先要经过这个Interceptor，看看 SignonInterceptor的源码，原来在其中为signon.jsp赋予一个signonForwardAction对象，呵呵，总算明白了。
3). 接下来去学习一下SignonController，其主体部分中可以看出，首先取出用户输入的username和password，然后到数据库中验证有没有这个用户，如果没有这个用户，返回各错误页面；如果成功，首先生成一个UserSession对象，在request的session加入这个 userSession，注意这部分代码中给出了PagedListHolder分页的简单使用方法，关于分页显示，以后再学习吧。

3、登录成功后，就可以根据不同的用户设施不同的行为了，取得用户信息，无非就是从session取出userSession即可。

chenguo 2007-06-18 18:05 发表评论

Spring学习笔记系列（六） aop

chenguo — Mon, 18 Jun 2007 10:03:00 GMT

实践了《指南》中的例子165页到169页，最后补充一个Action，
public class AOPMethodCostTimeAction extends ActionSupport {

public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response)
   throws Exception {
  WebApplicationContext wac = this.getWebApplicationContext();
  ITest dao =(ITest)wac.getBean("myAOPProxyFactory");
  dao.doTest();
  dao.executeTest();
  return mapping.findForward("success");
}

}
具体代码已经放到gmail邮箱了。

仅仅从这个例子总结一下：

1，配置文件中需要

myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">





    .*do.*
    .*execute.*



MyInterceptor" class="srx.test.interceptor.MethodTimeCostInterceptor">

myAOPProxyFactory" class="org.springframework.aop.framework.ProxyFactoryBean">

   srx.test.interfaces.ITest





   myPointcutAdvisor


test" class="srx.test.impl.test">

2，struts-config.xml

使用动态代理，我本来有ITest接口，及其实现类test。以及使用test的Action。现在，我想测试test

种方法的调用时间，我需要怎么做呢？

我只需要多定义三个Bean，myPointcutAdvisor，MyInterceptor，myAOPProxyFactory。

三者的依赖关系

myAOPProxyFactory [ myPointcutAdvisor [ MyInterceptor ] ]

其中advice定义和具体的Spring advice类有关系。

待续。

chenguo 2007-06-18 18:03 发表评论

Spring学习笔记系列（五）与hibernate整合 b

chenguo — Mon, 18 Jun 2007 10:02:00 GMT

常见问题及解决方案

现象1：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.springframework.aop.support.DefaultPointcutAdvisor' defined in null: Can't resolve reference to bean 'txAdvice' while setting property 'advice'; nested exception is

原因：缺少Spring开头的各种包，到Spring2.0 src中编译新的dist目录出来，拷贝全部的springxxx.jar到jpetstore/WEB-INF/lib下。OK。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

现象2：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'sessionFactory' defined in resource [/WEB-INF/dataAccessContext-hibernate.xml] of ServletContext: Instantiation of bean failed; nested exception is java.lang.NoClassDefFoundError: javax/transaction/TransactionManager
java.lang.NoClassDefFoundError: javax/transaction/TransactionManager

原因：缺少jta.jar，OK

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

现象3：

java.lang.NoClassDefFoundError: org/dom4j/Attribute
缺dom4j.jar
java.lang.NoClassDefFoundError: net/sf/ehcache/CacheException
缺ehcache.jar
java.lang.NoClassDefFoundError: net/sf/cglib/core/KeyFactory
缺cglib-full.jar

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

现象4：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'sessionFactory' defined in resource [/WEB-INF/dataAccessContext-hibernate.xml] of ServletContext: Initialization of bean failed; nested exception is net.sf.hibernate.MappingException: could not instantiate id generator
net.sf.hibernate.MappingException: could not instantiate id generator

原因：
hbm中id字段的定义为没有定义的sequesce,修改为inc
   name="id"
   type="string"
   column="userid"
  >
    // 原来是sequence.

这样就可以了。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

现象6：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name '/shop/addItemToCart.do' defined in ServletContext resource [/WEB-INF/petstore-servlet.xml]: Can't resolve reference to bean 'petStore' while setting property 'petStore'; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'petStore' is defined
org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'petStore' is defined
原因：
我使用Struts作为action,当然就不需要使用Spring WEB framework,因此也不需要与之配套的配置文件例如,petstore-servlet.xml,
还有remote-servlet.xml ,但是Spring仍旧加载此两个文件，没办法，只好将此两个文件挪动到别的地方，但是又出现找不到这两个
文件的IO异常，没办法，只好又拷贝回来，然后把文件内容晴空。
终于好用了。
原因就是，只要你在web.xml中定义了这个servlet，他就要去找此servlet名字对应的配置文件（servletname- servlet.xml）,找不到就出错。ok，现在注释掉web.xml中名字为petstore的servlet定义和影色，删除petstore- servlet.xml文件，哈哈，这下不报告错误了。
同理，注释名字为remote的servlet，删除remote-servlet.xml后，重新启动tomcat，这下不报告任何错误了。呵呵。原来如此啊。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象：
java.lang.NullPointerException
srx.test.testhibernate.UserDAO.getAll(UserDAO.java:9)
srx.test.struts.action.UserAction.execute(UserAction.java:20)
原因：

Action原来
UserDAO // 这个类OK
public class UserDAO extends HibernateDaoSupport {
public List getAll() {
return this.getHibernateTemplate().find("select aa from Account aa");
}
}

//这个类需要修改
public class UserAction extends ActionSupport {
UserDAO dao = new UserDAO();
List accounts = dao.getAll();
。。。
}
修改：
//UserDAO dao = new UserDAO();
WebApplicationContext wac = this.getWebApplicationContext();
UserDAO dao = (UserDAO) wac.getBean("userDAO");
OK

现象:
UserAction中修改:
//UserDAO dao = (UserDAO) wac.getBean("userDAO");
UserDAO dao = (UserDAO) wac.getBean("userDAOProxy"); //@1
配置文件中增加:







    PROPAGATION_REQUIRED
    PROPAGATION_REQUIRED,readOnly



这样运行时@1处抛出ClassCastException.
===================================================================================================
原因:
仔细看指南0.8版本145页所描述的事情.UserDAO虽然只继承了HibernateDAOSupport,看来没有事先任何接口,但是
HibernateDAOSupport实现了InitiralBean接口，所以UserDAO也相当于实现了这个接口。
因此本例按照实现了某个接口的DAO来处理，处理过程如下：
因为他实现了接口A，所以getBean得到一个实现了A的实例，并非继承UserDAO。所以用UserDAO转型会失败。
如果UserDAO没有实现接口A，那么getBean会得到一个UserDAO的子类实例，这时可以用UserDAO来转型。
综上所诉，UserDAO必须实现IUserDAO接口,并且用IUserDAO转型才行.
因为UserDAO必须继承HibernateDAOSupport,所以没有办法不实现任何接口.

本问题和AOP有关。因为对AOP还不熟悉，所以需要看看。

chenguo 2007-06-18 18:02 发表评论

Spring学习笔记系列（五）与hibernate整合 a

chenguo — Mon, 18 Jun 2007 10:01:00 GMT

在学习这一部分的时候我作了一个用StrutsAction访问UserDAO中方法，此方法使用了hibernateTemplate。调试过程中问题多多，好在一个一个解决了。

JPetStore2.0 已经有ibatis做为OR层了，我要换成hibernate需要修改Spring配置文件中的bean id="TransactionManager" 、增加bean id=“sessionFactory”。又因为配置文件id=TransactionManager的bean只能有一个，修改为hibernate后原来使用ibatis的bean就都不好用了，所以我新创建了一个空的配置文件dataAccessContext-hibernate.xml。只有几个字定义的bean，如下：

http://www.springframework.org/dtd/spring-beans.dtd">

  com.mysql.jdbc.Driver
  jdbc:mysql://localhost:3306/jpetstore
  root
  123456






    srx/test/hibernate/Account.hbm





     net.sf.hibernate.dialect.MySQLDialect


     true

原来包含很多复杂内容的applicationContext.xml也拷贝一份applicationContext2.xml，删除和JPetStore相关的内容，留下通用的部分：

    WEB-INF/mail.properties
    WEB-INF/jdbc.properties

在Struts配置文件中增加自己的Action如下：

web.xml中使用action作为*。do处理的servlet而不是默认的petstore。
并注释掉名字为petstore,remoting的servlet。如下：

http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">

Spring JPetStore

Spring JPetStore sample application

webAppRootKey
petstore.root

log4jConfigLocation
/WEB-INF/log4j.properties

  contextConfigLocation

   /WEB-INF/dataAccessContext-hibernate.xml

  org.springframework.web.context.ContextLoaderListener


  action
  org.apache.struts.action.ActionServlet
  3

action
*.do

...

chenguo 2007-06-18 18:01 发表评论

Spring学习笔记系列（三）异常处理

chenguo — Mon, 18 Jun 2007 10:00:00 GMT

配置Spring异常处理之需要增加一个bean的配置：

增加了一个异常处理的bean
/exception/failure /exception/showDBError /exception/showError

这样就可以统一分别处理不同Exception了。注意jsp页面在request中attribute等于“exception”,

而不是“Exception”注意大小写。页面如下：

错误显示页面
<%=ee.getMessage()%> <%ee.printStackTrace( new java.io.PrintWriter(out));%>

当然也可以做得更友好些，例如可以显示隐藏详细信息。

<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core_rt"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@ page contentType="text/html;charset=GBK" language="java" pageEncoding="GBK"%>
<%@ page import="java.util.Enumeration,java.util.Iterator"%>

this is failure

  <%=ee.getMessage()%>ok，

  <%ee.printStackTrace( new java.io.PrintWriter(out));%>

增加了一个异常处理的bean
/exception/failure /exception/showDBError /exception/showError

这样就可以统一分别处理不同Exception了。注意jsp页面在request中attribute等于“exception”,

而不是“Exception”注意大小写。页面如下：

错误显示页面
<%=ee.getMessage()%> <%ee.printStackTrace( new java.io.PrintWriter(out));%>

当然也可以做得更友好些，例如可以显示隐藏详细信息。

  <%=ee.getMessage()%>ok，

  <%ee.printStackTrace( new java.io.PrintWriter(out));%>

chenguo 2007-06-18 18:00 发表评论

Spring学习笔记系列（四）与struts整合

chenguo — Mon, 18 Jun 2007 10:00:00 GMT

《Spring开发指南》只写了一种与struts整合的方法，另一种到Spring2.0 Demo自带的Doc中查找到Action直接继承ActionSupport。详细信息:

To integrate your Struts application with Spring, you have two options:

Configure Spring to manage your Actions as beans, using the ContextLoaderPlugin, and set their dependencies in a Spring context file.
Subclass Spring's ActionSupport classes and grab your Spring-managed beans explicitly using a getWebApplicationContext() method.

16.3.2. ActionSupport Classes

As previously mentioned, you can retrieve the WebApplicationContext from the ServletContext using the WebApplicationContextUtils class. An easier way is to extend Spring's Action classes for Struts. For example, instead of subclassing Struts' Action class, you can subclass Spring's ActionSupport class.

The ActionSupport class provides additional convenience methods, like getWebApplicationContext(). Below is an example of how you might use this in an Action:

public class UserAction extends DispatchActionSupport {    public ActionForward execute(ActionMapping mapping,                                 ActionForm form,                                 HttpServletRequest request,                                 HttpServletResponse response)            throws Exception {        if (log.isDebugEnabled()) {            log.debug("entering 'delete' method...");        }        WebApplicationContext ctx = getWebApplicationContext();        UserManager mgr = (UserManager) ctx.getBean("userManager");        // talk to manager for business logic        return mapping.findForward("success");    }}

Spring includes subclasses for all of the standard Struts Actions - the Spring versions merely have Support appended to the name:

The recommended strategy is to use the approach that best suits your project. Subclassing makes your code more readable, and you know exactly how your dependencies are resolved. However, using the ContextLoaderPlugin allow you to easily add new dependencies in your context XML file. Either way, Spring provides some nice options for integrating the two frameworks.

可见第二种方法更加简便。

JPetstore例子中并没有使用此方法，而使用了第三种方法。同样只需要动Action。如下：

public abstract class BaseAction extends Action {

private PetStoreFacade petStore;

protected PetStoreFacade getPetStore() {
return petStore;
}

}
ok，这三种方法都可以让Spring与Struts整合，相比较第一种（因为配置很多这里没写，见refernce 16.3.1），
第二第三种方法比较简洁，侵入不多。

chenguo 2007-06-18 18:00 发表评论

Spring学习笔记系列（一）

chenguo — Mon, 18 Jun 2007 09:58:00 GMT

ApplicationContext ctx

1，定义资源文件获得资源文件的消息，国际化信息

xxxx

将会搜索xxxx.properties,xxxx_zh.properties ,xxxx_ch.properties等。

2，
程序里使用资源文件：ctx.getMessage('key',arg);
页面上使用资源文件：

3，使用其他文件。
Resource rs = ctx.getResource("classpath:config.properties");
File file = rs.getFile();
目录规则：
file：c：/test。txt
/config.properties
classpath:config.properties
三种方式。

4，事件传播
不过没有找到ApplicationListener这个类。

5, WebApp获取ApplicaionContext的方法，
首先是在web。xml中进行配置，可以配置成一个listener，也可以配置成一个servlet。
然后程序里使用WebApplicationContextUtils.getWebApplicationContext.获得饮用。

6，Spring可以和很多框架进行集成。
Struts+Spring，Webwork+Spring。

7，Spring可以有自己的调度类，DispatherServlet。
使用的配置文件就是beans的配置，名字可以随便取。

8，Sping配置文件（具体名字见web.xml中对ContextLoaderServlet的参数）类似于Struts的配置文件。
定义viewer使用的是系统类：
  org.springframework.web.servlet.view.InternalResourceViewResolver
Request mapping 使用的系统类：
  org.springframework.web.servlet.handler.SimpleUrlHandleMapping
对Action的定义使用自定义类，但这些类都是下面类的子类：
  SimpleFormController
Actoin的属性包括：
  1，跳转的页面，和view关联
  2，封装form类，就是一个普通的javabean。

9，Acition类的内容，
实现onsubmit（封装的form，异常对象）返回一个ModelAndView。
ModelAndView用字符串初始化，字符串来自Action的两个跳转view名称。
还可以把Map传入ModelAndView构造函数，用来返回消息。

10，Spring自带的数据验证功能。
10.1，验证类作为Aciotn的一个名为“validator”的属性在配置文件中配置。
此类继承org.springframework.validation.Validator
需要实现两个接口，support（传入一个类），验证此类是否是Action对应的form类。
validator（object obj，Errors err )首先把obj转为form类对象，如果有错误放到errors里，用法和
  struts类似。

10.2，表现层页面需要的显示错误
  全部错误：

   //遍历status.errorMessages


  单个错误：



    //遍历status.errorMessages


  如果已经在Action中配置了commandName，那么就不使用command了，而是使用配置的名字


    RegisterInfo

11, 异常处理
在Dispather的配置文件中配置

定义两个属性：


   sss
   yyy


可以按不同异常映射到不同的页面。
异常页面从request.getAttribute("Exception")取得Exception对象。显示他的message属性。

12，国际化
看完1后，补充如下：
Spring判断用户Locale的方式有三种，request中取，session中取，cookie中取客户端的locale。
分别用三个类，配置到配置文件中。

13，数据持久层（重要）对事务的封装
Spring是依赖容器的参数化事务管理不用写代码。
见p67。
1，在配置文件中配置完数据源，
2，之后配置事务管理的bean，数据源是它的属性。
3，DAO，事务员是它的属性。
4，事务beanDAOProxy，事务策略，事务bean，DAO都是它的属性。

14，数据持久层，对JDBC的封装
org.springframework.jdbc.core.JdbcTemplate.
JdbcTemplate jdbctemplate = new JdbcTemptlate( datasource );
jdbctemplate.update("xxxxx");
jdbctemplate.update("xxxxx",new PreparedStatementSetter(){
  public void setValues( PreparedStatementSetter ps ){
   ps.setInt(1,15);
   ps.setString(2,"jjjjjjj");
  }
});
jdbctemplate.query("select ...",new RollbackHandler(){
  public void processRow( ResultSet rs ){
   User user = new User();
   user.setName= rs.getString("name");
   userList.add( user )；
  }
});

.call()可以调用存储过程。
query,update还有很多不同版本的实现。

15, JDBC封装还要引入事务管理机制，默认是没有事务的。
两种方式
1，代码控制的，在DAO里TransactionTemplate使用它的方法。
2，参数化配置的事务。配置一个ProxyDAO，不用写这个类，只需要在配置文件里增加他对DAO的事物设置。
使得DAO代码十分简洁。

测试代码：
InputStream is = new FileInputStream("xxx.xml");
XmlBeanFactory factory = new XmlBeanFactoy( is );
UserDAO dao = (UserDAO)factory.getBean("ProxyDAO");
dao.insert();//这样就行了

16，Hibernate in Spring
只需修改配置文件增加一个bean名字为sessionFactory，数据源作为他的属性。
TrsactionManager的属性：sessionFactory
IDAO接口：定义数据库操作方法。
DAO的属性：sessionFactory。继承HibernateDAOSupport，并实现IDAO接口。
里面使用getHibernateTemplate模版进行数据库操作。
ProxyDAO的属性：transactionManager,DAO.

测试例子：
IUserDAO dao=(IUserDAO)factory.getBean("ProxyUserDAO");
User user = new User();
user.setxxx...
dao.insertOrUpdate(user);

chenguo 2007-06-18 17:58 发表评论

Spring学习笔记系列（二）

chenguo — Mon, 18 Jun 2007 09:53:00 GMT

Spring学习笔记二(2006.1.4)

1,配置文件的配置头

2，配置文件可以使用多个属性文件



    WEB-INF/mail.properties
    WEB-INF/jdbc.properties



类是框架的。
里面包含两个属性文件，属性文件里都是“key=value”这种形式的。这样配置文件里就可以使用属性文件里的key，使用方法
${key},这样转移出属性设置，维护起来比较方便。

3,定义Validator供web层使用，自定义类。

类里面使用了ValidatorUtils系统类来进行处理。

4，服务层的定义。
PetStoreImpl定义在配置文件中，是自己的类。
所有的DAO都是它的属性，注意，DAO是interface,而不是class.
PetStoreImpl中定义了所有的DAO接口作为属性，定义了他们的set方法，但是没有定义get方法。
这样所有的业务操作就可以不用管DAO是如何实现的了，而只管使用这个PetStoreImpl就好了。

DAO都是接口这种做法与平时开发不一样，我以前使用hibernate生成工具生成的dao都是默认好的实现类。
而此处的DAO却都是接口。他们的实现方法是这样的：
interface PetStoreFacade { } //定义所有的业务方法。
interface AccountDao{} //定义所有帐户的业务方法。
interface CategoryDao{} //定义类别的业务方法。
interface ProductDao{} //定义产品的业务方法。
。。。其他DAO接口，定义自己的业务方法。
class PetStoreImpl implements PetStoreFacade //这个类就是一个javabean，操作的都是接口。
//定义所有DAO接口当作自己的属性。
//实现set方法
//实现PetStoreFacade 定义的业务接口，实现的时候调用DAO接口的方法。

如果是我自己，那么就会定义IDAO当作接口，因为hibernate插件自动生成dao类，容易混淆。

5，配置文件中定义dataSource






可见，可以直接使用properties中的key。另外可以将数据库操作弄成另外一个配置文件。只要在web.xml中设置好就可以了，

  contextConfigLocation

   /WEB-INF/dataAccessContext-local.xml /WEB-INF/applicationContext.xml

6，配置文件中定义事务管理

使用了数据源作为属性。

7，dao具体实现类。
JPetStore使用ibatis作为ORM层。所以dao类的定义也都使用了ibatis。
PetStoreImpl五个接口接受五个实现了对应接口的实现类。这里的实现类，









实现类，使用ibatis。在配置文件中对英。
public class SqlMapAccountDao extends SqlMapClientDaoSupport implements AccountDao{
//实现了业务接口，继承了ibatis基本类。
}

8，ibatis基础类。





dao实现类都由他作属性。

9，我竟然找不到action对应的mapping在什么地方定义的。
后来找到了是petstore-servlet.xml,by default defined in "{servlet-name}-servlet.xml"...

  petstore
  org.springframework.web.servlet.DispatcherServlet
  2

原来是根据servlet名字命名影射文件的。
影射文件和配置文件的结构完全一致，也是beans开头的。主要是web层的url影射，





....

ok，现在把petstore-servlet.xml也放到SpringIDE里察看。

10，配置文件petstore-servlet.xml
viewResolver,定义了一个表现层的基本配置，此bean名字固定。
属性viewClass使用了jstl技术。

11，配置文件petstore-servlet.xml
defaultHandlerMapping使用默认的BeanNameUrl影射，具体不太明白。

12，配置文件petstore-servlet.xml
定义*.do

属性petStore是在applicationContext.xml里定义的，看来这里也可以使用其他定义的bean。

13，*.do类研究
实现了Controller，接口public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
有一个属性petstore,是一个接口PetStoreFacade，包括全部业务逻辑接口。

14，首页index
在mapping文件里定义了系统ParameterizableViewController，相当于forwardAction。

而首页里大量使用了jstl语言，最重要的地方是所有 a href=, action=,处都使用了
这样的定义，这样换域名或者设置虚拟目录名，就会运行正常了。例如，

">

">

">

">

">

15，进入首页后点左边的链接都指向同一个viewCategory.do,



类研究：
ViewCategoryController implement Controller
里面只使用了PetStore实现类的方法，并没有DAO对象。只有Domain对象。
很好，把主要的和业务相关的东西都在Controller中展现出来了，其他辅助的东西都被隐藏了，使得Controller非常简洁。
另外，在业务PetStoreImp类中，使用了DAO，这样就使得后台程序也开始分层了。

|--层Controller及使用的daomain对象 /// 第一层
            |----层PetStoreFacade 接口及他的实现类PetStoreImpl //第二层
   |-------- 层DAO接口，DAO接口实现类，//第三层
    |------------实现类中使用的ORM类 //第四层
层次非常的分明。

daomain符合javabean规范，并且有些javabean还有自己的public方法。大多数javabean没有必要有public方法。

16, 点击分类后，显示分类中的items，点items可以进入viewProduct.do？productId=xxx，来观看产品。

这是一个翻页功能的Controller。
没弄清楚成功后跳转到什么地方？ return new ModelAndView("Product", model);没有理解。

public class ModelAndViewextends ObjectHolder for both Model and View in the web MVC framework. Note that these are entirely distinct. This class merely holds both to make it possible for a controller to return both model and view in a single return value.

Class to represent a model and view returned by a handler used by a DispatcherServlet. The view can take the form of a reference to a View object, or a String view name which will need to be resolved by a ViewResolver object. The model is a Map, allowing the use of multiple data objects keyed by name.

public ModelAndView(String viewName,
Map model)Creates new ModelAndView given a view name and a model.

Parameters:
viewName - name of the View to render, to be resolved by the DispatcherServlet
model - Map of model names (Strings) to model objects (Objects). Model entries may not be null, but the model Map may be null if there is no model data.

这样viewName就知道了，返回给DispatcherServerlet,再根据viewResolver中的定义，就可以知道是/jsp/spring/Product.jsp了。
也就是说，viewName也就是jsp文件的名字。

17，ModelAndView传递给页面之后页面如何使用其中的数据？
Controller传递的model是一个map，一共传递了两个key-value对。
model.put("itemList", itemList);
model.put("product", product);
ok，看jsp页面。

">









">


原来是把key当作attributename放到了request范围内了。这样就ok了，model的key实际上就是request的属性名字啊。
model的value就是request的属性值。jstl真正发挥简洁的威力了。

18，viewProduct.do里还有一个翻页的逻辑，没看明白怎么回事。

19，viewProduct.do之后再点链接就进入了viewItem.do,相对简单。不用看了。
PagedListHolder itemList = new PagedListHolder(this.petStore.getItemListByProduct(productId));
java.lang.Object
org.springframework.beans.support.PagedListHolder
PagedListHolder is a simple state holder for handling lists of objects, separating them into pages. Page numbering starts with 0.
Constructor Summary
PagedListHolder()
          Create a new holder instance.
PagedListHolder(List source)
          Create a new holder instance with the given source list, starting with a default sort definition (with "toggleAscendingOnProperty" activated).
PagedListHolder(List source, SortDefinition sort)
          Create a new holder instance with the given source list.
boolean isFirstPage()
          Return if the current page is the first one.
boolean isLastPage()
          Return if the current page is the last one.
void nextPage()
          Switch to next page.
void previousPage()
          Switch to previous page.
可以排序。可以设置页数。
这个类明显是把所有的结果一次性查询出来后，设定每页个数，之后再把当页数据发送给页面。虽然不是把全部数据发送给页面由页面来分页，但是一次把全部数据都查询出来的做法只适合少量数据。如果多量数据几万条的话同时查出来，存放到session，用不了多久服务器的内存就被耗光了。
还不太清楚放到session中的对象什么时候被晴空，好像只有在退出的时候才晴空一次。

20，addItemToCart.do?workingItemId=EST-11，代码很清楚。有两点主意：
一，webUtil org.springframework.web.util.webUtil提供了有限的几个方法。
二，return new ModelAndView("Cart", "cart", cart); // Cart.jsp , key ,value
因为不熟悉ibatis所以ORM层的代码都没有阅读，也就是PetsoreImpl实现类的各个DAO实例都没有阅读。

removeItemFromCart.do?workingItemId=EST-11 也是同一页面上的购物车操作，过于简单。略
updateCartQuantities.do //更新的是内存中的数据，所以没有什么技术。

21，checkout.do有一点需要注意，别的Controller没有传入viewName。它传了，

Controller中：
private String successView;

public void setSuccessView(String successView) {
this.successView = successView;
}
最后return new ModelAndView(this.successView, "cart", cart);

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=571067

chenguo 2007-06-18 17:53 发表评论

Springweb 表现层集成技术

chenguo — Wed, 13 Jun 2007 01:53:00 GMT

摘要: 13.1. 简介Spring之所以出色的一个原因就是将表现层从MVC的框架中分离出来。例如，通过配置就可以让Velocity或者XSLT来代替已经存在的JSP页面。本章介绍和Spring集成的一些主流表现层技术，并简要描述如何集成新的表现层。这里假设你已经熟悉第 12.5 节 “视图与视图解析”，那里介绍了将表现层集成到MVC框架中的基本知识。13.2. 和JSP &... 阅读全文

chenguo 2007-06-13 09:53 发表评论

BlogJava-Exciting IN JAVA WAY-文章分类-Spring Dev

Spring aop

Spring例子JPetStore分析---------3jpetstore的各层之间的关系部分分析

分析和学习Spring中的jpetstore用户管理

Spring学习笔记系列（六） aop

Spring学习笔记系列（五） 与hibernate整合 b

Spring学习笔记系列（五） 与hibernate整合 a

Spring学习笔记系列（三） 异常处理

Spring学习笔记系列（四） 与struts整合

16.3.2. ActionSupport Classes

Spring学习笔记系列（一）

Spring学习笔记系列（二）

Springweb 表现层集成技术

Spring学习笔记系列（五）与hibernate整合 b

Spring学习笔记系列（五）与hibernate整合 a

Spring学习笔记系列（三）异常处理

Spring学习笔记系列（四）与struts整合