风信Java论坛

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上

唧唧 — 2010-07-29 09:52:09.0

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图所示：

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Spring能做什么？

jastby — 2010-07-16 15:31:48.0

　　Spring提供许多功能,在此我将快速地依次展示其各个主要方面。

　　首先,让我们明确Spring范围。尽管Spring覆盖了许多方面，但我们已经有清楚的概念，它什么应该涉及和什么不应该涉及。

　　Spring的主要目的是使J2EE易用和促进好编程习惯。

　　Spring不重新开发已有的东西。因此，在Spring中你将发现没有日志记录的包,没有连接池,没有分布事务调度。这些均有开源项目提供(例如Commons Logging 用来做所有的日志输出，或Commons DBCP用来作数据连接池),或由你的应用程序服务器提供。因为同样的的原因，我们没有提供O/R mapping层，对此，已有有好的解决办法如Hibernate和JDO。

　　Spring的目标是使已存在的技术更加易用。

　　例如,尽管我们没有底层事务协调处理，但我们提供了一个抽象层覆盖了JTA或任何其他的事务策略。

　　Spring没有直接和其他的开源项目竞争，除非我们感到我们能提供新的一些东西。例如，象许多开发人员，我们从来没有为Struts高兴过，并且感到在MVC web framework中还有改进的余地。在某些领域，例如轻量级的IoC容器和AOP框架，Spring有直接的竞争，但是在这些领域还没有已经较为流行的解决方案。(Spring在这些区域是开路先锋。)

　　Spring也得益于内在的一致性。

　　所有的开发者都在唱同样的的赞歌,基础想法依然是Expert One-on-One J2EE设计与开发的那些。

　　并且我们已经能够使用一些主要的概念,例如倒置控制，来处理多个领域。

　　Spring在应用服务器之间是可移植的。

　　当然保证可移植性总是一次挑战，但是我们避免任何特定平台或非标准化,并且支持在WebLogic，Tomcat，Resin，JBoss，WebSphere和其他的应用服务器上的用户。

Spring框架的好处

jastby — 2010-07-16 15:30:15.0

　　在我们进入细节以前，让我们看一下Spring可以给一个工程带来的一些好处:

　　◆Spring能有效地组织你的中间层对象,无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题。

　　◆Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。

　　◆Spring能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？有了Spring，你可很简单地看到类的JavaBean属性。倒置控制的使用(在下面讨论)帮助完成这种简化。

　　◆Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。

　　◆Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。

　　◆使用Spring构建的应用程序易于单元测试。

　　◆Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。

　　◆Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。

　　■Spring为数据存取提供了一致的框架,不论是使用JDBC或O/R mapping产品（如Hibernate）。

　　Spring确实使你能通过最简单可行的解决办法解决你的问题。这些特性是有很大价值的。

　　总结起来，Spring有如下优点：

　　◆低侵入式设计，代码污染极低

　　◆ 独立于各种应用服务器，可以真正实现Write Once,Run Anywhere的承诺

　　◆Spring的DI机制降低了业务对象替换的复杂性

　　◆Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

Spring带给我们什么

jastby — 2010-07-16 15:29:08.0

　　◆方便解耦，简化开发
　　通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

　　◆AOP编程的支持
　　通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

　　◆声明式事务的支持
　　在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

　　◆方便程序的测试
　　可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。

　　◆方便集成各种优秀框架
　　Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hession、Quartz）等的直接支持。

　　◆降低Java EE API的使用难度
　　Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

　　◆Java 源码是经典学习范例
　　Spring的源码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

为什么需要Spring

jastby — 2010-07-16 15:27:51.0

　　你可能正在想“Spring不过是另外一个的framework”。当已经有许多开放源代码(和专有) J2EE framework时，我们为什么还需要Spring Framework？

　　Spring是独特的,因为若干个原因:

　　◆它定位的领域是许多其他流行的framework没有的。Spring关注提供一种方法管理你的业务对象。

　　◆ Spring是全面的和模块化的。Spring有分层的体系结构,这意味着你能选择使用它孤立的任何部分,它的架构仍然是内在稳定的。因此从你的学习中，你可得到最大的价值。例如,你可能选择仅仅使用Spring来简单化JDBC的使用,或用来管理所有的业务对象。

　　◆它的设计从底部帮助你编写易于测试的代码。Spring是用于测试驱动工程的理想的framework。

　　Spring对你的工程来说，它不需要一个以上的framework。Spring是潜在地一站式解决方案，定位于与典型应用相关的大部分基础结构。它也涉及到其他framework没有考虑到的内容。

Spring简介

jastby — 2010-07-16 15:27:08.0

　　Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

　　◆目的：解决企业应用开发的复杂性

　　◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

　　◆范围：任何Java应用

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

　　◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

　　◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

　　◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

　　◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

　　◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

　　所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

Spring的起源和背景

jastby — 2010-07-16 15:23:01.0

　　Rod Johson在2002年编著的《Expert one to one J2EE design and development》一书中，对Java EE正统框架臃肿、低效、脱离现实的种种现状提出了质疑，并积极寻求探索革新之道。以此书为指导思想，他编写了interface21框架，这是一个力图冲破Java EE传统开发的困境，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。同年他又推出了一部堪称经典的力作《Expert one-to-one J2EE Development without EJB》，该书在Java世界掀起了轩然大波，不断改变着Java开发者程序设计和开发的思考方式。在该书中，作者根据自己多年丰富的实践经验，对EJB的各种笨重臃肿的结构进行了逐一的分析和否定，并分别以简洁实用的方式替换之。至此一战功成，Rod Johnson成为一个改变Java世界的大师级人物。

　　传统J2EE应用的开发效率低，应用服务器厂商对各种技术的支持并没有真正统一，导致J2EE的应用没有真正实现Write Once及Run Anywhere的承诺。Spring作为开源的中间件，独立于各种应用服务器，甚至无须应用服务器的支持，也能提供应用服务器的功能，如声明式事务等。

　　Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而是与它们无缝地整合。

Spring与Struts1的集成

jastby — 2010-07-15 10:23:38.0

Spring和Struts整合的价值在于将Struts使用的BO或DAO 乃至Action交给Spring管理，从而充分利用Spring强大的IoC和AOP 特性。

无论使用哪种方式整合，都需要为 Struts装载 Spring 应用上下文环境。有以下三种方式：

1) 在struts-config.xml中使用Struts Plugin

value="/WEB-INF/classes/applicationContext.xml,/WEB-INF/action-servlet.xml"/>

2) 在web.xml中使用ContextLoaderListener

contextConfigLocation
/WEB-INF/classes/applicationContext.xml

org.springframework.web.context.ContextLoaderListener

3) 在web.xml中使用ContextLoaderServlet

contextConfigLocation
/WEB-INF/classes/applicationContext.xml

SpringContextServlet

org.springframework.web.context.ContextLoaderServlet

1

注意：用Struts PlugIn的方式加载Spring配置文件有可能导致DWR无法取得Spring中定义的bean，因为DWR有可能先于Struts被访问使用，而此时Struts配置文件还未加载！
因此，在Spring、Struts和DWR 集成时，应该在web.xml中通过ContextLoaderLisenter或ContextLoaderServlet加载Spring配置文件。
最佳实践是使用Struts PlugIn的方式加载Struts Action配置文件/WEB-INF/action-servlet.xml，而使用ContextLoaderLisenter或ContextLoaderServlet方式加载Spring配置文件applicationContext.xml，通过两次加载完成Spring所有配置文件的加载。

至少有四种Spring与Struts整合方式：

1. 手工创建Spring 环境整合 Spring和Struts

为了Web应用环境可以和Spring的IoC容器很好的结合，Spring提供了专门用于Web应用环境中的Spring容器——WebApplicationContext。使用ContextLoaderPlugIn装载 Spring 应用程序环境时，ContextLoaderPlugIn会自动创建一个WebApplicationContext对象，并加载相应的配置文件，然后将其保存在ServletContext中。之后所有的Servlet或Action便都可以过ServletContext访问该WebApplicationContext实例并从中获取BO或DAO Bean。

ServletContext servletContext=this.getServlet().getServletContext();
WebApplicationContext ctx=
WebApplicationContextUtils.getWebApplicationContext(servletContext);
UserInfoDAO userInfoDAO=(UserInfoDAO)ctx.getBean("userInfoDAO");

2. 使用 Spring 的 ActionSupport 类整合 Struts

org.springframework.web.struts.ActionSupport 类提供了一个 getWebApplicationContext() 方法可以获取到WebApplicationContext实例，您所做的只是从 Spring 的 ActionSupport 而不是 Struts Action 类扩展您的动作：

public class AddActionSupport extends ActionSupport {
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
AddForm addForm = (AddForm) form;
UserInfo user=new UserInfo();
user.setUserName(addForm.getName());
user.setUserPwd(addForm.getPassword());
UserInfoDAO userInfoDAO=
(UserInfoDAO)getWebApplicationContext().getBean("userInfoDAO");
userInfoDAO.save(user);
return mapping.findForward("success");
}
}

结论：第1、2种整合方式由Spring来管理BO或DAO Bean，实现了表示层和业务逻辑层的解耦，但Struts的Action和Spring耦合在了一起，违反了Spring“非侵入”性原则；另外,Action类负责查找由Spring管理的Bean,也违背了Spring控制反转(IoC)的原则。以下第3、4种整合方式实现了由Spring来管理Struts Action，实现了Struts和Spring的解耦，从而解决了以上问题。

3. 使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor

用Spring的DelegatingRequestProcessor重载Struts 默认的 RequestProcessor。这样当收到一个针对Action的请求时，DelegatingRequestProcessor会自动从Spring Context中查找对应的Action Bean。

在struts-config.xml中添加：

4. 【最佳方案】使用DelegatingActionProxy将Struts Action 管理全权委托给 Spring 框架

即：使用spring的aop动态代理机制
Action 的创建和对象的依赖注入全部由IOC容器来完成，使用Spring的DelegatingAcionProxy来帮助实现代理的工作。DelegatingActiongProxy继承于org.apache.struts.action.Action 。此时需要将struts-config.xml中所有Action类别全部配置为 org.springframework.web.struts.DelegatingActionProxy：

3、4两种方式都需要在WEB-INF下新建一个action-servlet.xml作为Spring context文件，创建Struts Action Bean，并对Action进行BO或DAO Bean注入：

结论：以上2种方式实现了由Spring管理Struts的Action，从而可以利用Spring在Struts Action中轻松的注入BO或DAO，还可以将 Spring 的 AOP 拦截器应用于Struts 动作，用最小的代价处理横切关注点。

第3种整合方式只需要配置一个，不需要改动Struts Action配置信息，但Struts的 RequestProcessor只能被重载一次，如果在应用中还要进行编码等其它功能RequestProcessor重载时，此种方式将异常繁琐。

第4种整合方式可以避免RequestProcessor的占用，但必须将struts-config.xml中所有Action类别全部配置为 org.springframework.web.struts.DelegatingActionProxy。

Cannot find the declaration of element "beans"

jastby — 2009-07-03 14:40:17.0

今天第一次学习配置spring，按照教程配置好的时候，启动异常：

2009-7-3 14:30:05 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.FileSystemXmlApplicationContext@c1b531: display name [org.springframework.context.support.FileSystemXmlApplicationContext@c1b531]; startup date [Fri Jul 03 14:30:05 CST 2009]; root of context hierarchy
2009-7-3 14:30:05 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from file [D:\MyWorkSpace\jwcms\bean.xml]
Exception in thread "main" org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException: Line 2 in XML document from file [D:\MyWorkSpace\jwcms\bean.xml] is invalid; nested exception is org.xml.sax.SAXParseException: cvc-elt.1: Cannot find the declaration of element 'beans'.
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:404)
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:342)
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:310)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:143)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:178)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:149)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:212)
at org.springframework.context.support.AbstractXmlApplicationContext.loadBeanDefinitions(AbstractXmlApplicationContext.java:113)
at org.springframework.context.support.AbstractXmlApplicationContext.loadBeanDefinitions(AbstractXmlApplicationContext.java:80)
at org.springframework.context.support.AbstractRefreshableApplicationContext.refreshBeanFactory(AbstractRefreshableApplicationContext.java:123)
at org.springframework.context.support.AbstractApplicationContext.obtainFreshBeanFactory(AbstractApplicationContext.java:422)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:352)
at org.springframework.context.support.FileSystemXmlApplicationContext.(FileSystemXmlApplicationContext.java:140)
at org.springframework.context.support.FileSystemXmlApplicationContext.(FileSystemXmlApplicationContext.java:84)
at com.javawind.test.TestQuickStart.testQuickStart(TestQuickStart.java:15)
at com.javawind.test.TestQuickStart.main(TestQuickStart.java:11)
Caused by: org.xml.sax.SAXParseException: cvc-elt.1: Cannot find the declaration of element 'beans'.
at com.sun.org.apache.xerces.internal.util.ErrorHandlerWrapper.createSAXParseException(ErrorHandlerWrapper.java:195)
at com.sun.org.apache.xerces.internal.util.ErrorHandlerWrapper.error(ErrorHandlerWrapper.java:131)
at com.sun.org.apache.xerces.internal.impl.XMLErrorReporter.reportError(XMLErrorReporter.java:384)
at com.sun.org.apache.xerces.internal.impl.XMLErrorReporter.reportError(XMLErrorReporter.java:318)
at com.sun.org.apache.xerces.internal.impl.xs.XMLSchemaValidator.handleStartElement(XMLSchemaValidator.java:1887)
at com.sun.org.apache.xerces.internal.impl.xs.XMLSchemaValidator.startElement(XMLSchemaValidator.java:685)
at com.sun.org.apache.xerces.internal.impl.XMLNSDocumentScannerImpl.scanStartElement(XMLNSDocumentScannerImpl.java:400)
at com.sun.org.apache.xerces.internal.impl.XMLNSDocumentScannerImpl$NSContentDriver.scanRootElementHook(XMLNSDocumentScannerImpl.java:626)
at com.sun.org.apache.xerces.internal.impl.XMLDocumentFragmentScannerImpl$FragmentContentDriver.next(XMLDocumentFragmentScannerImpl.java:3095)
at com.sun.org.apache.xerces.internal.impl.XMLDocumentScannerImpl$PrologDriver.next(XMLDocumentScannerImpl.java:921)
at com.sun.org.apache.xerces.internal.impl.XMLDocumentScannerImpl.next(XMLDocumentScannerImpl.java:648)
at com.sun.org.apache.xerces.internal.impl.XMLNSDocumentScannerImpl.next(XMLNSDocumentScannerImpl.java:140)
at com.sun.org.apache.xerces.internal.impl.XMLDocumentFragmentScannerImpl.scanDocument(XMLDocumentFragmentScannerImpl.java:510)
at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(XML11Configuration.java:807)
at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(XML11Configuration.java:737)
at com.sun.org.apache.xerces.internal.parsers.XMLParser.parse(XMLParser.java:107)
at com.sun.org.apache.xerces.internal.parsers.DOMParser.parse(DOMParser.java:225)
at com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderImpl.parse(DocumentBuilderImpl.java:283)
at org.springframework.beans.factory.xml.DefaultDocumentLoader.loadDocument(DefaultDocumentLoader.java:75)
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:396)
... 15 more

google一番后得到解决方法，bean.xml 如下：

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

原来我少了红色的那行，补充上去就好了。

Spring 开发指南 (Spring_Dev_Guide)[pdf]

唧唧 — 2009-04-30 10:45:38.0

Spring 开发指南 V0.8 预览版 (作者：夏昕)

SpringFramework 实际上是Expert One-on-One J2EE Design and Development 一书中所阐述的设计思想的具体实现。在One-on-One 一书中，Rod Johnson 倡导J2EE 实用主义的设计思想，并随书提供了一个初步的开发框架实现（interface21 开发包）。而SpringFramework 正是这一思想的更全面和具体的体现。Rod Johnson 在interface21 开发包的基础之上，进行了进一步的改造和扩充，使其发展
为一个更加开放、清晰、全面、高效的开发框架。

本文正是针对SpringFramework的开发指南，讲述了SpringFramework的设计思想以及在开发中的实际使用。同时穿插了一些笔者在项目实作中的经验所得。

下载： 30_1046_F266751.pdf

Spring WebFlow：重用与抽象框架解析之一

唧唧 — 2009-04-27 12:07:13.0

Spring WebFlow是一个全新的Web框架，她带给我们一种全新且高度结构化的Web应用构建方法。让我们来看看她的一些特性。

Spring框架正准备推出一种新的技术。在下一个版本中Spring将正式将Spring WebFlow整合进来。Spring WebFlow是一个及其优秀的Web开发框架，用于在Web应用内部创建和配置可重用的Web流程。

熟悉Spring的人可能先入为主地以为Spring WeFlow和SpringMVC没有什么区别。那就错了。Spring MVC是一个轻量级的Web开发框架，而Spring WebFlow 则提出一种全新的视角。她使得Web架构师们可以将精力集中在Web应用开发的抽象层次上:Web流程的逻辑结构和Web事件条件的定义。此外，她还提出许多新的概念。

本文将回顾这一个新框架前的一些关键概念，用一个经典的用户登录例子来分析流程标记语言的主要组成元素并向您解释为什么WebFlow如此诱人。

Spring WebFlow 概念和组件作为一个Web框架，WebFlow无论在理论上还是在实际开发上都有诸多优点。深厚的软件工程学架构保证了他的稳定性，同时，其组件合理，易于理解，易于使用。

事实上，它更适合中大型应用的开发，因为它的组件模型专门针对架构重用，高效管理性和可配置性进行了优化。

用例研究

本文以一个常见的web应用流程作为示例，一个身份认证流程，讲解它的一些代码片断。一个Web认证的全过程包括:登录表单，注册表单，认证action，注册action，以及对这些action的结构修饰。这个例子用来展示那些修饰登录表单的组件的配置。

自动操作架构

Spring WebFlow以有限自动机(Finite State machine)的概念为基础。Web应用内部的用户交互行为和事务被建模为一般的状态机，这是一种非常流行的软件工程建模方法。(见图1)。自动机为基础的设计是一种很好的设计方法，同时正在越来越收到应用架构的青睐——因为它在对Web交互行为建模时显得相对清晰且严谨。

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

...

...

这个流程以loginForm开始，以"successView"结束(修饰主页面"displayMain" 的组件。流程可以通过XML文档配置，或者AbstractFlowBuilder的子类。

动作状态(ActionStates)

ActionStates对用户事件或其他事件进行响应。ActionStates自身又可以包含其他可执行的Action和transition。下面的代码配置了"loginForm"这个ActionState。

动作(Actions)

Action是ActionState可以连接，重用，声明调用的最小单位。Action继承自AbstractAction类，该类实现了doExecuteAction方法。这个方法的参数:RequestContext，WebFlow(其中封装了所有流程相关的数据)。

loginForm动作状态通过Spring的自动装配特性调用LoginFormAction动作。doExecute

Action方法被自动调用，同时可以处理一些登录准备，预先装入等操作。

public LoginFormAction extends AbstractAction
{

protected Event doExecuteAction
(RequestContext context)
throws Exception
{
//perform some login specific setup operations
...

}//end method

}//end class

显示状态(ViewState)

ViewState初始化对显示组件(jsp，tile等)的修饰操作。下面是一个ViewState的配置代码：

当来自loginForm的ActionState返回一个"success"时，这个ViewState将会被调用。它将修饰"enterCredentials"显示组件(可以是一个常见的struts forward)。

跳转(Transition)

和通常的状态机一样，WebFlow定义了状态以及状态之间跳转动作。这些跳转动作很类似struts中的ActionForward。同样是负责连接两个状态。

后继动作(Continuation)

后继动作(Continuation)允许你回退并重新开始程序执行流程——从程序执行的角度来看是一个适时的逆流程。Continuation的概念最早来自编程语言，但是却从来没有被用于像Java，VB，C++这样主流的编程语言中。WebFlow创造性地实现了continuation。由于continuation可以用来持久和重造任何一个流程状态，从而提供给你极大的自由。

Spring的三种配置数据源的方式

唧唧 — 2009-04-23 12:42:19.0

（1）：加载properties文件方式

properties文件加载有两种方式

(a) src下config下所有后缀为properties的文件全部加载

(b) 加载指定位置的properties文件

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

/WEB-INF/classes/configure.properties

properties文件引用方式

p:driverClassName="${jdbc.driverClassName}"
p:url="${jdbc.url}"
p:username="${jdbc.username}"
p:password="${jdbc.password}"/>

（2）：把jndi的字符串配置到properties文件中读取！

${jdbc.dataSource}

（3）：直接给定jndi的字符串

Spring中遇到问题,请高手解答

gy93108083 — 2008-09-28 07:08:28.0

最近用Spring遇到一个问题

package com.app.dao;

public class DAO {

public DAO() {
super();
System.out.println("create dao !!!!!");
}

}

package com.app.service;

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

import com.app.dao.DAO;

public class Service {

private static ApplicationContext context = null;
static{

new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("after create context!!! ");
}

public Service() {
super();
System.out.println("create Serice!!!!");
}

public void UseService(){
System.out.println("before get dao!!!");
DAO dao= (DAO)context.getBean("mydao");
System.out.println("after get dao! ");
}

}

package com.app.test;

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

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
}

}

这样的代码运行没有问题

但是,如果把service里改成

public class Service {

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

public Service() {
super();
System.out.println("create Serice!!!!");
}

public void UseService(){
System.out.println("before get dao!!!");
DAO dao= (DAO)context.getBean("mydao");
System.out.println("after get dao! ");
}

}

就会出现死循环,请问这是什么原因导致的??????????????????????????

【对于Spring初学者的学习建议】

suieui — 2008-09-06 09:53:07.0

一、首先Java的基础、面向对象的基础和设计模式的基础知识是必不可少的。
　　关于设计模式我觉得不用学太多，但以下三个模式是学习Spring必不可少的：factory模式（包括简单工厂和抽象工厂），Strategy模式，Template method模式。如果不掌握这些你就根本没法领悟Spring的精髓，只能依样画葫芦地照搬，这是很可怕的事。

　　我这里强烈建议的书可能让人有点意外，那就是Expert one on one J2EE design and development的第四章，这一章不仅仅是Spring初学者，而是任何搞Java开发的人必读的一章。经典！

　　二、接下可以看一些Spring的入门书籍
　其实我自己没怎么看过这方面的书，我当时只看过Spring的reference，不过现在这方面的书好象多的是，而Spring reference看起来还是有些吃力的。JavaEye上很多人建议夏昕的Spring开发指南，据说入门很容易。另外的入门书应该是Spring live或Spring in action。我大概扫了一下，Spring live是一本只讲怎么做而不讲为什么的书，我不太喜欢（偶尔参考一下倒不错），不过有些人特别喜欢这样的书，看自己的个人爱好吧。

　　三、研究几个用Spring做的开源项目
　　理论还是要与实际结合，所以看完书后是要看实际的项目的。很多人喜欢appfuse，我觉得appfuse花的东西太多，真正实质性的内容又太少。我更喜欢Spring自带的jpetstore，这是一个非常完整的例子，看完后Spring的基本用法应该都能掌握。

　　四、开始做实际的项目
　　在上述这些都完备以后，我觉得应该要去实际项目中锻炼了。当然并不是每人都有这样的机会的，这时只能自己做个玩具项目啦。项目的锻炼是非常关键的，其实每个人都清楚，我就不重复了。

　　五、继续深入学习
　　经过项目的锤炼，对Spring的用法和原理有了一定的了解的时候，才有可能真正掌握Spring的精髓。这时要读的书才是Rod Johnson的三本经典名著，分别是：

　　Expert one on one J2ee design and development

　　Expert one on one J2ee without EJB

　　Professional Java Development with SpringFramework

　　前两本书的经典程度我就不说了，只有读了它们，才能真正了解Spring的设计意图，掌握Spring的精髓。

　　第三本书是我强烈不建议初学者读的书。里面的东西深入而全，但是原理讲解得又不够深，很容易让初学者犯迷糊。但是却是Spring的高级用户必读的一本书（还有一本pro Spring据说也不错，不过我没读过）。我过几天会写一下这本书的书评。

　　当然这个阶段与第四阶段是交错的，边读书边做项目学到的东西才会更多的。

　　六、分析源代码，扩展Spring
　　有人认为没有必要分析Spring的源代码，因为这是很累人又不计好的事。但是要想成为Spring的高级用户，这是必经的阶段。在学习的过程中，我们学到的不仅是Spring，更重要的是他的设计思想。不管怎样，看牛人的源代码是绝对有好处的。不过这是一个很累人的过程，要有思考准备哦！

想学习J2EE与SPring的朋友，特推荐《轻量级J2EE企业应用实战》与《Spring 2.0宝典》是由李刚老师――东方标准（原新东方职业教育中心）广州中心软件教学总监所编，李刚老师在新东方担任培训讲师期间，培训了大量优秀学生，已经在华为、网易、亿阳、立信、普信、中企动力等公司就职，在珠三角的J2EE行业极具号召力。有机会大家也可以去了解下！教学地址就在广州华南师范大学计算机学院6楼。或者可访问：http://soft.oneedu.cn

＆◆Spring学习笔记◆＆

kitymao200 — 2008-08-07 10:58:19.0

计划用一个月时间来学习Spring，在这里把自己的学习过程记录下来，方便想学习Spring的人，也为自己日后复习有个参考。以下通过一个简单的例子来先了解下Spring的用法。
(1)创建一个java工程，建立如下类：HelloBean

package com.ducklyl;

public class HelloBean {
private String helloWord;

public String getHelloWord() {
return helloWord;
}

public void setHelloWord(String helloWord) {
this.helloWord = helloWord;
}

}

(2)创建Spring配置文件：beans-config.xml

Hello,ducklyl!

(3)导入Spring所需的包：commons-logging.jar，spring.jar 。(日志包和Spring包)
包下载地址：
http://www.blogjava.net/Files/ducklyl/Spring.rar
(4)创建测试类：SpringDemo.java

package com.ducklyl;

import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.*;

public class SpringDemo{
public static void main(String[] args)
{
  //读取配置文件
  Resource rs=new FileSystemResource("beans-config.xml");
  //实例化Bean工厂
  BeanFactory factory=new XmlBeanFactory(rs);

  //获取id="helloBean"对象
  HelloBean hello=(HelloBean)factory.getBean("helloBean");
  //调用helloBean对象getHelloWord()方法
  System.out.println(hello.getHelloWord());
}

}

如果以上配置正确的话，运行SpringDemo.java，可以看到输出结果：Hello,ducklyl！

要想了解更多JAVA知识,请访问http://soft.oneedu.cn/

Spring 基础教程(三)

唧唧 — 2008-07-23 02:02:21.0

属性编辑器: PropertyEditorSupport
作用:如果一个类中的属性为Date类型,那么在beans.xml中设置的Date值不能与Date匹配,那么我们需要对beans.xml中的属性进行编辑,让它转化为Date类型的
CustomEditorConfigurer可以读取实现java.beans.PropertyEditor接口的类,将字符串转为指定的类型,更方便的使用PropertyEditorSupport.PropertyEditorSupport实现PropertyEditor,必须重新定义setAsText
程序目标:如果bean类中有不是一般类型的属性的话,并且在xml文件中有这个属性的赋值，那么可以使用属性编辑器对属性进行类型的封装，然后通过org.springframework.beans.factory.config.CustomEditorConfigurer类在xml中与属性编辑器处理类绑定
接口:
package yuchen.dataeditor;

public interface A {
     public void display();
}

实现类:
package yuchen.dataeditor;

import java.util.Date;

public class AImp implements A {

     private Date date;
     public void display() {
         // TODO Auto-generated method stub
         if(date instanceof Date){
              System.out.println(date);
         }

     }
     public Date getDate() {
         return date;
     }
     public void setDate(Date date) {
         this.date = date;
     }

}

属性编辑器类
package yuchen.dataeditor;

import java.beans.PropertyEditorSupport;//属性编辑器
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class DateEditor extends PropertyEditorSupport {

     private Date date;
     @Override
     public void setAsText(String str) throws IllegalArgumentException {
         // TODO Auto-generated method stub
         String[] a=str.split("/");
         int year = Integer.parseInt(a[0]);
         int month = Integer.parseInt(a[1]);
         int day = Integer.parseInt(a[2]);
         Calendar cal= new GregorianCalendar(year,month-1,day);
         date = cal.getTime();
     }

     @Override
     public Object getValue() {
         // TODO Auto-generated method stub
         return date;
     }

}

xml:

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



              1998/07/07



     class="org.springframework.beans.factory.config.CustomEditorConfigurer">



                       class="yuchen.dataeditor.DateEditor"/>





Test:
package yuchen.dataeditor;
/*
* 属性编辑器:java.beans.PropertyEditorSupport
* 如何知道属性编辑器类为谁服务呢?
* class="org.springframework.beans.factory.config.CustomEditorConfigurer">



                       class="yuchen.dataeditor.DateEditor"/>




*/
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     public static void main(String[] args) {
         ApplicationContext context=new
ClassPathXmlApplicationContext("yuchen/dataeditor/beans.xml");
         A aa=(A) context.getBean("a");
         aa.display();
     }

}

属性设置器:
除了通过beans.xml设置属性以外，还可以通过PropertyPlaceholderConfigurer为bean属性设置值，它利用属性文件
程序目标:测试PropertyPlaceholderConfigurer类

接口:
package yuchen.propertyphc;

public interface A {
     public void display();
}

实现类:
package yuchen.propertyphc;

import java.util.Date;

public class AImp implements A {

     private Date date;
     public void display() {
         // TODO Auto-generated method stub
         if(date instanceof Date){
              System.out.println(date);
         }

     }
     public Date getDate() {
         return date;
     }
     public void setDate(Date date) {
         this.date = date;
     }

}

属性编辑器:
package yuchen.propertyphc;

import java.beans.PropertyEditorSupport;//属性编辑器
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class DateEditor extends PropertyEditorSupport {

     private Date date;
     @Override
     public void setAsText(String str) throws IllegalArgumentException {
         // TODO Auto-generated method stub
         String[] a=str.split("/");
         int year = Integer.parseInt(a[0]);
         int month = Integer.parseInt(a[1]);
         int day = Integer.parseInt(a[2]);
         Calendar cal= new GregorianCalendar(year,month-1,day);
         date = cal.getTime();
     }

     @Override
     public Object getValue() {
         // TODO Auto-generated method stub
         return date;
     }

}

属性文件:
date=2001/10/3

xml:

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



              ${date}



     class="org.springframework.beans.factory.config.CustomEditorConfigurer">



                       class="yuchen.propertyphc.DateEditor"/>





     class="org.springframework.beans.factory.config.PropertyPlaceholderConfigur
er">



yuchen/propertyphc/AImp.properties




Test:
package yuchen.propertyphc;
/*
* 属性设置器:
* 通过属性文件给bean的属性设置值
* 在beans.xml中添加属性设置器类:
* class="org.springframework.beans.factory.config.PropertyPlaceholderConfigur
er">



yuchen/propertyphc/AImp.properties



     属性文件:
     date=2001/10/3
*/
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     public static void main(String[] args) {
         ApplicationContext context=new
ClassPathXmlApplicationContext("yuchen/propertyphc/beans.xml");
         A aa=(A) context.getBean("a");
         aa.display();
     }

}

属性覆盖器:
作用:属性文件中设置好的属性值将会覆盖掉beans.xml中类属性值
接口:
package yuchen.propertypoc;

public interface A {
     public void display();
}

实现类:
package yuchen.propertypoc;

import java.util.Date;

public class AImp implements A {

     private String name;
     public void display() {
         // TODO Auto-generated method stub
         System.out.println(this.name);

     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }


}

xml:

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



              zhao



     class="org.springframework.beans.factory.config.PropertyOverrideConfigurer"
>

              yuchen/propertypoc/AImp.properties



属性文件:
a.name=yuchen

Test:
package yuchen.propertypoc;
/*
* 覆盖:
* 使用PropertyOverrideConfigurer那么属性文件中设置的属性值
* 会覆盖在beans.xml 的bean类中设置的属性值
*/
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     public static void main(String[] args) {
         ApplicationContext context=new
ClassPathXmlApplicationContext("yuchen/propertypoc/beans.xml");
         A aa=(A) context.getBean("a");
         aa.display();
     }

}

ApplicationContext的事件特性(观察者模式):
1.ApplicationContext发布事务
2.事件响应者需要实现ApplicationListener
3.定义一个事件类,继承ApplicationEvent
接口:
package yuchen.event;

public interface Model {
     public String superDate();
     public void update();
}

接口:
package yuchen.event;

public interface View {
     public void display();
}

实现类:
package yuchen.event;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;

public class ModelImpl implements Model,ApplicationContextAware{

     private String name;
     private ApplicationContext context;
     public String superDate() {
         // TODO Auto-generated method stub
         return name;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public void update(){
         this.setName("zhang");
         if(context!=null){
              context.publishEvent(new RefreshEvent(this,"update
()"));
         }else{
              System.out.println("null");
         }

     }
     public void setApplicationContext(ApplicationContext arg0) throws
BeansException {
         // TODO Auto-generated method stub
         context=arg0;
     }
}

实现类:
package yuchen.event;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;

public class ViewImpl implements View,ApplicationListener{
     private Model model;
     public void display() {
         // TODO Auto-generated method stub
         String rst=model.superDate();
         System.out.println(rst);
     }
     public Model getModel() {
         return model;
     }
     public void setModel(Model model) {
         this.model = model;
     }
     public void onApplicationEvent(ApplicationEvent arg0) {
         // TODO Auto-generated method stub
         if(arg0 instanceof RefreshEvent){
         System.out.println("事件发生后调用onApplicationEvent方法");
         this.display();
         }
     }

}

事件类:
package yuchen.event;

import org.springframework.context.ApplicationEvent;

public class RefreshEvent extends ApplicationEvent{
     private String message;
     public RefreshEvent(Object arg0,String message) {
         super(arg0);
         this.message=message;
         // TODO Auto-generated constructor stub
     }
     public String getMessage() {
         return message;
     }
     public void setMessage(String message) {
         this.message = message;
     }

}

xml:

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



              yuchen









Test:
package yuchen.event;
/*
* 程序目标:当更新model里的name时,context发布事件,再次调用display方法
* ApplicationContext用来发布事件
* ApplicationEvent为事件的抽象类,需要继承此类声明一个事件对象
* ApplicationListener监听器监听是否有事件发生,当context发布事件
* 后,会调用实现了此接口的bean中的onApplicationEvent()方法
* 实现ApplicationContextAware的类可获得context
*/
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         ApplicationContext context=new
ClassPathXmlApplicationContext("yuchen/event/beans.xml");
         View v=(View) context.getBean("view");
         v.display();
         System.out.println("----------------");
         ModelImpl m=(ModelImpl)context.getBean("model");
         m.update();
     }

}

国际化:
ApplicationContext的getMessage方法可以做国际化
并且在beans.xml中需要配置国际化文件的路径

修改上面的类：将消息的内容国际化
ModelImpl.java:
public void update(){
         this.setName("zhang");
         if(context!=null){
              //context.publishEvent(new RefreshEvent(this,"update()"));
              context.publishEvent(new RefreshEvent(this,context.getMessage("message", new String[]{"message","!!!!!"}, Locale.CHINA)));
         }else{
              System.out.println("null");
         }

     }

加入国际化属性文件：
message_zh.properties:
message = {0} \u5237\u65b0 {1}

Message_en.properties:
message = {0} refresh{1}

修改beans.xml:
加入：



                   yuchen/event/message




工厂bean:
以前的程序都是通过容器产生工厂，容器的表现有两种
1.XmlBeanFactory
2.ApplicationContext
现在不用得到工厂，通过一个工厂bean去得到bean实例
产生的实例为工厂bean创建的产品,并不是工厂对象

package yuchen.factorybean;

import java.util.Properties;

import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
Test:
public class Test {

     /**
      * @param args
      * @throws Exception
      */
     public static void main(String[] args) throws Exception {
         ApplicationContext factory = new
ClassPathXmlApplicationContext("yuchen/factorybean/beans.xml");
         long s = (Long)factory.getBean("a");

         System.out.println(s);



         String classpath = (String)factory.getBean("classpath");
         System.out.println(classpath);

         FactoryBean o =(FactoryBean)factory.getBean("&classpath");
         String classpath2 = (String)o.getObject();
         System.out.println(classpath2);
     }

}

beans.xml:

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

     class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
         name="targetClass">java.lang.System
   name="targetMethod">currentTimeMillis



     class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
         value="java.lang.System">




     class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
         local="props"/>
         value="getProperty">

              java.class.path




面向方面编程AOP:
1.什么是面向方面编程?有什么用?
2.一个陈旧的案例
3.AOP的一些概念
4.第一个AOP程序
5.前置Advice
6.后置Advice
7.环绕Advice
8.异常抛出Advice

什么是面向方面编程?有什么用?
面向方面编程就是就是将类中掺杂的与业务无关的代码抽象出来,以便重用
作用:重用,解耦合

包含两个要素:
1.在哪里加入服务(方法前?方法后?属性?)
2.具体为哪个类的哪个方法或属性加入服务

例如:
1.要在方法前加入事务服务
2.为A类的sayhello()业务方法加入服务
两者组合就是一个方面

一个陈旧的案例:
程序目标:为A类的业务方法1加入事务和安全的服务,为业务方法2只加入事务的服务
package yuchen.aop.oldcase;

public class OldCase {

     public void execute1(){
         safetybackcheck();
         System.out.println("事务开始代码");
         this.operation1();
         System.out.println("事务结束代码");
     }

     public void execute2(){
         System.out.println("事务开始代码");
         this.operation2();
         System.out.println("事务结束代码");
     }

     public void safetybackcheck(){
         System.out.println("安全检查代码");
     }

     public void operation1(){
         System.out.println("业务代码1");
     }

     public void operation2(){
         System.out.println("业务代码2");
     }
}

发现问题:业务代码和服务代码互相掺杂,结构不清晰,维护代码不方便,也不方便重用
那么使用AOP编程就是为了解决这个问题

AOP的一些概念:
关注点:业务核心代码(如: operation1)和系统服务代码(事务,安全代码)都是关注点
横切关注点:程序中的系统服务代码都是横切关注点
核心关注点:就是业务核心代码
方面(aspect):advice+pointcut=aspect,一个方面说明了为哪些类的哪些方法,属性等加入哪些服务,例如:为A类的a()方法加入事务,安全服务,这就是方面
advice: 在哪里加入服务(方法前?方法后?属性?),就是拦截器
pointcut: 具体为哪个类的哪个方法或属性加入服务
连接点:能插入服务的位置是连接点:如:方法,属性,异常抛出,Spring Aop只支持一种类型的连接点(方法)
织入(weaving):就是将方面加入到具体的哪个对象中
Aop代理:Aop Proxy:代理对象,他去调用被包装了服务的业务方法
AOP的目标就是要将横切关注点与核心关注点分离,实现解耦合,重用这些服务

第一个AOP程序:
接口:
package yuchen.aop.firstaop;

public interface Business {
     public void business1();
     public void business2();
}

核心业务类:
package yuchen.aop.firstaop;

public class BusinessImpl implements Business {

     public void busMethod1(){
         this.business1();
     }
     public void busMethod2(){
         this.business2();
     }
     public void business1() {
         // TODO Auto-generated method stub
         System.out.println("核心业务方法1");
     }

     public void business2() {
         // TODO Auto-generated method stub
         System.out.println("核心业务方法2");
     }

}

安全服务:
package yuchen.aop.firstaop;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class SecuityBeforeAdvice implements MethodBeforeAdvice{

     public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
         // TODO Auto-generated method stub
         this.check();
     }

     public void check(){
         System.out.println("安全检查");
     }
}

事务服务:
package yuchen.aop.firstaop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class AffairAroundAdvice implements MethodInterceptor{

     public Object invoke(MethodInvocation arg0) throws Throwable {
         // TODO Auto-generated method stub
         this.transactionStart();
         Object object=arg0.proceed();
         this.transactionEnd();
         return object;
     }

     public void transactionStart(){
         System.out.println("事务开始");
     }

     public void transactionEnd(){
         System.out.println("事务结束");
     }
}

事务服务pointcut:
package yuchen.aop.firstaop;

import java.lang.reflect.Method;

import org.springframework.aop.ClassFilter;
import org.springframework.aop.support.StaticMethodMatcherPointcut;

public class PointcutImpl extends StaticMethodMatcherPointcut{

     public boolean matches(Method arg0, Class arg1) {
         // TODO Auto-generated method stub
         if(arg0.getName().equals("business1")){
              return true;
         }
         return false;
     }

     @Override
     public ClassFilter getClassFilter() {
         // TODO Auto-generated method stub
         return new ClassFilter(){

              public boolean matches(Class arg0) {
                   // TODO Auto-generated method stub
                   return (arg0==BusinessImpl.class);
              }

         };
     }

}

Test:
package yuchen.aop.firstaop;
/*
* 为类中的某些方法加上事务和安全
*/
import org.springframework.aop.Advisor;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ProxyFactory pf=new ProxyFactory();
         Business bi=new BusinessImpl();
         SecuityBeforeAdvice sb=new SecuityBeforeAdvice();
         Pointcut p=new PointcutImpl();
         Advisor advisor=new DefaultPointcutAdvisor(p,sb);
         AffairAroundAdvice ad=new AffairAroundAdvice();
         pf.addAdvisor(advisor);
         pf.addAdvice(ad);
         pf.setTarget(bi);
         Business b=(Business) pf.getProxy();
         b.business1();
         b.business2();
     }

}
开发步骤:
1.写核心业务类
2.写系统服务类(advice)
3.选择性的写过滤类(pointcut)
4.写客户代码:通过DefaultPointcutAdvisor将advice and pointcut组装,代理工厂添加advice,设置目标对象,生成代理对象,代理对象调用业务方法

使用proxyfactorybean方式:
添加配置文件:

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

































                   befadvisor
                   affair




修改Test:
package yuchen.aop.updatefirstaop;

import org.springframework.aop.Advisor;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ApplicationContext context=new ClassPathXmlApplicationContext("yuchen/aop/updatefirstaop/beans.xml");
         Business b=(Business) context.getBean("factory");
         b.busMethod1();
     }

}
前置Advice:
接口:
package yuchen.aop.before.proxyfactory;

public interface Business {
     public void busMethod1();
     public void busMethod2();
}

核心业务实现类:
package yuchen.aop.before.proxyfactory;

public class BusinessImpl implements Business {

     public void busMethod1(){
         this.business1();
     }
     public void busMethod2(){
         this.business2();
     }
     public void business1() {
         // TODO Auto-generated method stub
         System.out.println("核心业务方法1");
     }

     public void business2() {
         // TODO Auto-generated method stub
         System.out.println("核心业务方法2");
     }

}

实体类:
package yuchen.aop.before.proxyfactory;

public class UserInfo {
     private String username;
     private String password;

     public UserInfo() {
         super();
     }

     public UserInfo(String username, String password) {
         super();
         this.username = username;
         this.password = password;
     }

     public String getPassword() {
         return password;
     }
     public void setPassword(String password) {
          this.password = password;
     }
     public String getUsername() {
         return username;
     }
     public void setUsername(String username) {
         this.username = username;
     }

}

用户登陆管理类:
package yuchen.aop.before.proxyfactory;

public class UserMagager {
     private static ThreadLocal t=new ThreadLocal();
     public static void login(String username,String password){
         t.set(new UserInfo(username,password));
     }
     public static void logout(){
         t.set(null);
     }
     public static UserInfo getUserInfo(){
         return (UserInfo)t.get();
     }
     public static void validate(){
         UserInfo user=getUserInfo();
         if(user==null){
              throw new UserInfoException("您还没有登陆");
         }else if(user.getUsername().equals("admin")){
              System.out.println("系统管理员登陆");
         }else{
              throw new UserInfoException("您不是系统管理员");
         }
     }
}

自定义异常:
package yuchen.aop.before.proxyfactory;

public class UserInfoException extends RuntimeException {
     public UserInfoException(String msg){
         super(msg);
     }
}

前置advice:
package yuchen.aop.before.proxyfactory;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class SecuityBeforeAdvice implements MethodBeforeAdvice{

     public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
         // TODO Auto-generated method stub
         UserMagager.validate();
     }

}

Test:
package yuchen.aop.before.proxyfactory;
/*
* 当抛出异常的时候,拦截器中断
*/
import org.springframework.aop.framework.ProxyFactory;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Business bi=getProxyFactory();
         try{
              bi.busMethod1();
         }catch(UserInfoException ue){
              System.out.println(ue.getMessage());
         }
         UserMagager.login("admin", "1234");
         bi.busMethod1();
         UserMagager.logout();

         UserMagager.login("yuchen", "123");
         try{
              bi.busMethod1();
         }catch(UserInfoException ue){
              System.out.println(ue.getMessage());
         }

     }

     public static Business getProxyFactory(){
         ProxyFactory pf=new ProxyFactory();
         Business business=new BusinessImpl();
         SecuityBeforeAdvice sa=new SecuityBeforeAdvice();
         pf.setTarget(business);
         pf.addAdvice(sa);
         return (Business)pf.getProxy();
     }
}

采用声明服务方式:
xml:

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
















                   secuity




修改Test:
package yuchen.aop.before.proxyfactorybean;
/*
* 当抛出异常的时候,拦截器中断
*/
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     public static void main(String[] args) {
         ApplicationContext context=new ClassPathXmlApplicationContext("yuchen/aop/before/proxyfactorybean/beans.xml");
         Business business=(Business) context.getBean("factory");

         UserMagager.login("admin", "123");
         business.busMethod1();
         business.busMethod2();
         UserMagager.logout();

         UserMagager.login("yuchen", "1");
         try{
              business.busMethod1();
         }catch(UserInfoException ue){
              System.out.println(ue.getMessage());
         }
         UserMagager.logout();

         try{
              business.busMethod1();
         }catch(UserInfoException ue){
              System.out.println(ue.getMessage());
         }

     }

}

后置Advice:
实体类:
package yuchen.aop.after.proxyfactory;
/*
* 业务类
*/
public class Man {
     private String name;
     private int age;

     public Man() {
         super();
     }

     public Man(String name, int age) {
         super();
         this.name = name;
         this.age = age;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Man growup(){
         ++age;
         return this;
     }
}

核心业务类:
package yuchen.aop.after.proxyfactory;
/**
* 服务:方法计数器
*/
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class Counter {
     private static Map countmap=new HashMap();//存方法名和调用次数

     public Map getCountmap() {
         return countmap;
     }

     public void setCountmap(Map countmap) {
         this.countmap = countmap;
     }

     public void count(Method method){
         count(method.getName());
     }

     //计算方法调用的次数并保存到一个map表中
     public void count(String name){
         Integer i=(Integer) countmap.get("name");
         if(i!=null){
              countmap.put(name, new Integer(i.intValue()+1));
         }else{
              countmap.put(name, 1);
         }
     }
     //返回方法调用的次数
     public int getCount(String name){
         int x;
         Integer i=(Integer) countmap.get(name);
         if(i==null){
              x=0;
         }else{
              x=i.intValue();
         }
         return x;
     }

}

后置advice:
package yuchen.aop.after.proxyfactory;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class CountAgeAfterAdvice extends Counter implements AfterReturningAdvice{

     public void afterReturning(Object returnvalue, Method method, Object[] parameter, Object target) throws Throwable {
         // TODO Auto-generated method stub
         //returnvalue:被拦截的方法的返回值
         //method:被拦截的方法
         //parameter:被拦截的方法的参数
         //target:被拦截的目标对象
         this.count(method);//被拦截的对象的方法调用后执行

         if(method.getName().equals("growup")){
              Man man=(Man)returnvalue;
              System.out.println(man.getName()+":"+man.getAge());
              System.out.println(this.getCount(method.getName()));
         }

     }

}

Test:
package yuchen.aop.after.proxyfactory;

import org.aopalliance.aop.Advice;
import org.springframework.aop.framework.ProxyFactory;

public class Test {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Man man=new Man("yuchen",24);
         CountAgeAfterAdvice counter=new CountAgeAfterAdvice();
         ProxyFactory pf=new ProxyFactory();
         pf.addAdvice(counter);
         pf.setTarget(man);
         Man m=(Man) pf.getProxy();

         m.growup();

     }

}

声明式:xml:

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



              yuchen


              24














                   counterage




修改Test:
package yuchen.aop.after.proxyfactorybean;

import org.aopalliance.aop.Advice;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ApplicationContext context=new ClassPathXmlApplicationContext("yuchen/aop/after/proxyfactorybean/beans.xml");
         Man man=(Man) context.getBean("factory");
         System.out.println(man.getName()+":"+man.getAge());
         man.growup();
     }

}

环绕Advice:
业务核心类:
package yuchen.aop.interception.proxyfactory;

public class AccountWork {
     public void account(int num){
         for(int i=0;i               work();
         }
     }

     public void work(){
         System.out.println("工作中....");
     }
}

环绕advice:
package yuchen.aop.interception.proxyfactory;

import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.util.StopWatch;

public class AccountCapabilityAdvice implements MethodInterceptor{

     public Object invoke(MethodInvocation invocation) throws Throwable {
         // TODO Auto-generated method stub
         StopWatch sw=new StopWatch();
         sw.start(invocation.getMethod().getName());
         Object obj=invocation.proceed();
         sw.stop();
         this.displaybulletin(invocation, sw.getTotalTimeMillis());
         return obj;
     }

     private void displaybulletin(MethodInvocation invocation,long l){
         Method m=invocation.getMethod();
         Object obj=invocation.getThis();
         Object[] arg=invocation.getArguments();
         System.out.println("目标类:"+obj.getClass().getName());
         System.out.println("方法:"+m.getName());
         System.out.print("方法参数:");
         for(int i=0;i               System.out.print(arg[i]);
              if(i!=arg.length-1){
                   System.out.println(",");
              }else{
                   System.out.println(".");
              }
         }
         System.out.println("性能测试时间:"+l);
     }
}

Test:
package yuchen.aop.interception.proxyfactory;

import org.springframework.aop.framework.ProxyFactory;

public class Test {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         AccountWork aa=getproxyfactory();
         aa.account(100);
     }

     private static AccountWork getproxyfactory(){
         ProxyFactory pf=new ProxyFactory();
         AccountWork aw=new AccountWork();
         AccountCapabilityAdvice aca=new AccountCapabilityAdvice();
         pf.setTarget(aw);
         pf.addAdvice(aca);
         return (AccountWork)pf.getProxy();
         }
}

声明方式:
xml:

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















                   acadvice




修改Test:
package yuchen.aop.interception.proxyfactorybean;

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ApplicationContext context=new ClassPathXmlApplicationContext("yuchen/aop/interception/proxyfactorybean/beans.xml");
         AccountWork aw=(AccountWork) context.getBean("factory");
         aw.account(100);
     }
}

异常抛出Advice:
业务核心类:
package yuchen.aop.exception.proxyfactory;

import java.rmi.RemoteException;

public class ExceptionBean {
     public void exception1() throws RemoteException{
         throw new RemoteException("远程方法调用异常");
     }
}

异常抛出advice:
package yuchen.aop.exception.proxyfactory;

import java.lang.reflect.Method;
import java.rmi.RemoteException;

import org.springframework.aop.ThrowsAdvice;

public class ExceptionAdvice implements ThrowsAdvice{
     public void afterThrowing(Method method,Object[] args,Object target,RemoteException re){
         System.out.println("抛出异常的方法名:"+method);
         System.out.println("目标对象:"+target.getClass().getName());
         System.out.println("异常信息:"+re.getMessage());
     }
}

Test:
package yuchen.aop.exception.proxyfactory;

import java.rmi.RemoteException;

import org.springframework.aop.framework.ProxyFactory;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ExceptionBean bean=getProxyFactory();
         try {
              bean.exception1();
         } catch (RemoteException e) {
              // TODO Auto-generated catch block
         }
     }
     public static ExceptionBean getProxyFactory(){
         ProxyFactory pf=new ProxyFactory();
         ExceptionBean eb=new ExceptionBean();
         ExceptionAdvice ea=new ExceptionAdvice();
         pf.setTarget(eb);
         pf.addAdvice(ea);
         return (ExceptionBean)pf.getProxy();
     }
}

声明式方式:

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
















                   advice




修改Test:
package yuchen.aop.exception.proxyfactorybean;

import java.rmi.RemoteException;

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ApplicationContext context=new ClassPathXmlApplicationContext("yuchen/aop/exception/proxyfactorybean/beans.xml");
         ExceptionBean bean=(ExceptionBean) context.getBean("factory");
         try {
              bean.exception1();
         } catch (RemoteException e) {
              // TODO Auto-generated catch block
         }
     }
}

Spring 基础教程(二)

唧唧 — 2008-07-23 01:59:33.0

依赖注入的三种方式:
1.基于接口注入
2.构造方法注入
3.set注入

基于接口注入:
只要实现制定的接口,那么便创建对象,类似于标示接口,比如说:servlet的pagecontext等,只要实现了servlet接口,那么pagecontext,request,response,ServletContext等就会创建

构造方法注入:
顾名思义,通过构造方法注入对象的属性,这种方式不常用

Set注入:
通过set方法注入对象信息,这个用的最多

ApplicationContext:
通常使用ClassPathXmlApplicationContext这个类来代替XmlBeanFactory

FileResource:
得到资源文件(xml)的另一种方式:绝对路径方式,一般使用的不多

综合例子(依赖注入and ClassPathXmlApplicationContext):
程序目标:测试构造方法注入和set注入
Model接口:
package yuchen.immit.constructimmit;

public interface Model {
     public String supportData();
}

view接口:
package yuchen.immit.constructimmit;

public interface View {
     public void render();
}

ModelImp实现类:
package yuchen.immit.constructimmit;

public class ModelImp implements Model {

     //set注入
     private String ownerName;
     private double balance;
     //构造方法注入
     private String city;
     public ModelImp(String city){
         this.city=city;
     }
     public String supportData() {
         // TODO Auto-generated method stub
         return "model : \n"+"ownerName :"+this.ownerName+
         "\n balance :"+this.balance+"\n city:"+city;
     }
     public double getBalance() {
         return balance;
     }
     public void setBalance(double balance) {
         this.balance = balance;
     }
     public String getOwnerName() {
         return ownerName;
     }
     public void setOwnerName(String ownerName) {
         this.ownerName = ownerName;
     }

}

ViewImp:
package yuchen.immit.constructimmit;

public class ViewImp implements View {

     private Model model;
     private Model model2;//构造方法注入
     public ViewImp(Model model2){
         this.model2=model2;
     }
     public void render() {
         // TODO Auto-generated method stub
//       String rst=model2.supportData();构造注入的ModelImp对象
         String rst=model.supportData();
         System.out.println(rst);
     }
     public Model getModel() {
         return model;
     }
     public void setModel(Model model) {
         this.model = model;
     }

}

beans.xml:

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



              北京


              yuchen


              1000.67












Test:
package yuchen.immit.constructimmit;

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
//       ClassPathResource resource=new ClassPathResource
("yuchen/immit/constructimmit/beans.xml");
//       XmlBeanFactory factory=new XmlBeanFactory(resource);
         ClassPathXmlApplicationContext factory=new
ClassPathXmlApplicationContext("yuchen/immit/constructimmit/beans.xml");
         View view=(View) factory.getBean("view");
         view.render();
     }

}

Ioc依赖注入的特点:
1.对spring没有依赖性,程序不依赖于spring指定的Api
2.bean都是单例的,除非在bean的属性修改
3.支持基本类型,引用类型和集合类型

接口:
package yuchen.ioccharacteristic;

public interface IocCharacteristic {
     public void display();
}

实现类:
package yuchen.ioccharacteristic;

import java.util.Map;

public class IocCharacteristicImp implements IocCharacteristic {

     private Map map;
     public void display() {
         // TODO Auto-generated method stub
         System.out.println("display"+this.map);
     }
     public Map getMap() {
         return map;
     }
     public void setMap(Map map) {
         this.map = map;
     }

}

beans.xml:

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





                       yuchen


                       liu


                       li





Test:
package yuchen.ioccharacteristic;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ClassPathXmlApplicationContext factory=new ClassPathXmlApplicationContext ("yuchen/ioccharacteristic/beans.xml");
         IocCharacteristic ic=(IocCharacteristic) factory.getBean("ioc");
         IocCharacteristic ic2=(IocCharacteristic) factory.getBean("ioc");
         //默认情况下都是单例模式,除非修改beans.xml bean 属性:singleton="false"
         System.out.println(ic==ic2);
         ic.display();
     }

}

Bean的创建:
1.工厂类创建:A.静态方法 B.new 工厂类
2.XmlBeanFactory:当getBean的时候创建bean实例
3.ClassPathXmlApplicationContext:当new这个对象后,就将资源中的bean读入到内存

程序目标:
一个类的属性的值通过一个工厂类的方法得到,这个工厂类有两个方法,一个是静态的,一个是成员方法,测试工厂类的使用

接口:
package yuchen.factory;

public interface Factory {
     public void display();
}

实现类:
package yuchen.factory;

public class FactoryImp implements Factory {

     public String name;
     public void display() {
         // TODO Auto-generated method stub
         System.out.println(name);
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }

}

工厂类:
package yuchen.factory;
//工厂类:一个静态,一个动态
public class GetNameFactory {
     public static String createName(String s){
         if(s.equals("yuchen")){
              return "yuchen";
         }else if(s.equals("liu")){
              return "liu";
         }
         return null;

     }
     public String newName(String s){
         if(s.equals("yuchen")){
              return "yuchen";
         }else if(s.equals("liu")){
              return "liu";
         }
         return null;

     }
}

beans.xml:

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







     method="createName">

              yuchen




     method="newName">

              liu



Test:
package yuchen.factory;
/*
* 知识点:使用工厂类的方法,给其他类的属性设置值
* 语法:beans.xml:静态方法:
*
* 成员方法:
*

              liu


     使用该工厂的类:



*/
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
     public static void main(String [] args){
         ClassPathXmlApplicationContext factory=new
ClassPathXmlApplicationContext("yuchen/factory/beans.xml");
         Factory f=(Factory) factory.getBean("fac");
         f.display();
     }
}

继承属性:
若干个bean,共有一个属性,使用继承
A类:a,b属性已经set或通过构造方法(属性a,属性b)设置好
B类:也有a,b同名属性
那么在beans.xml中使用,B 继承 A就可以了,不用在xml中从新设置

抽象属性:
不能得到该类的实例

自动装配bean:
自动设置依赖关系:例如:A类持有B类的引用,引用属性名字和xml中的B类的id名字相同,那么会自动装配好
autowire="byName|byType|constructor"
byName:属性—id 推荐
byType:找类名匹配,存在问题,当一个类多次出现会报错
constructor:根据构造方法类型匹配

依赖检查:dependency-check="all"
检查所有的set方法是否都被调用了,例如:如果有属性缺少set方法,那么会报异常

生命周期方法定制:
两种方式:1.使用bean属性 2.实现接口(不推荐,框架侵入性强:依赖API)
在构造方法和依赖注入set后调用init

综合实例(继承属性, 自动装配bean, 依赖检查,生命周期方法定制):
A接口:
package yuchen.beansp;

public interface A {
     public void display();
}

B接口:
package yuchen.beansp;

public interface B {
     public void dispaly();
}

A实现类:
package yuchen.beansp;

public class AImp implements A {
     private String name;
     private int age;
     public AImp(String name) {
         super();
         this.name = name;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public String getName() {
         return name;
     }
     public void display() {
         // TODO Auto-generated method stub
         System.out.println("Aimp: \n");
         System.out.println(this.name+":"+this.age);
     }

}

B实现类:
package yuchen.beansp;

public class BImp implements B {
     private A a;
     private String name;
     private int age;
     public BImp(String name) {
         super();
         this.name = name;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public void dispaly() {
         // TODO Auto-generated method stub
         System.out.println("Bimp: \n");
         System.out.println(this.name+":"+this.age);
         a.display();
     }
     public void setA(A a) {
         this.a = a;
     }
     public void init(){
         System.out.println("init....");
     }
     public void destroy(){
         System.out.println("destroy....");
     }

}

beans.xml:

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



              yuchen


              24







Test:
package yuchen.beansp;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ClassPathXmlApplicationContext factory=new ClassPathXmlApplicationContext("yuchen/beansp/beans.xml");
         B bb=(B) factory.getBean("b");
         A aa=(A) factory.getBean("a");
         aa.display();
         bb.dispaly();
     }

}

获得当前bean的bean工厂对象和bean的实例名字(beans.xml中):
Bean类必须实现BeanFactoryAware接口
注意:不能使用依赖检查了,因为这个接口的方法不要求有set方法

Bean类必须实现BeanNameAware接口
注意:不能使用依赖检查了,因为这个接口的方法不要求有set方法

接口:
package yuchen.factoryandname;

public interface Bird {

}

实现类:
package yuchen.factoryandname;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;

public class CaiBird implements Bird ,BeanFactoryAware,BeanNameAware{
     private String color;

     public String getColor() {
         return color;
     }

     public void setColor(String color) {
         this.color = color;
     }

     public void setBeanFactory(BeanFactory arg0) throws BeansException {
         // TODO Auto-generated method stub
         System.out.println("当前bean的bean工厂");
     }

     public void setBeanName(String arg0) {
         // TODO Auto-generated method stub
         System.out.println(arg0+":"+this.color);
     }

}

xml:

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



              红色



Test:
package yuchen.factoryandname;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ClassPathXmlApplicationContext factory=new ClassPathXmlApplicationContext ("yuchen/factoryandname/beans.xml");
         Bird bb=(Bird) factory.getBean("bird");
     }

}

以上内容为bean工厂部分

AppLicationContext
基本概念:
1.什么是ApplicationContext?有什么用?
2.和bean工厂的区别?
3.后续处理器

什么是ApplicationContext?有什么用?
是bean工厂的升级,增强了功能,例如国际化等
通过这个类可以得到bean对象

和bean工厂的区别?
功能更多
当实例这个对象的时候,该对象就会将资源中的bean实例存储到内存中

后续处理器:
BeanPostProcessor
作用:可以在使用该实例前增加一些处理操作

程序目标:
接口:
package yuchen.beanpostprocessor;

public interface A {
     public void display();
}

实现类:
package yuchen.beanpostprocessor;

public class AImp implements A {
     private String name;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public void display(){
         System.out.println(this.name);
     }
}

后续处理器:
package yuchen.beanpostprocessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class UpperNamePostProcessor implements BeanPostProcessor{

     public Object postProcessAfterInitialization(Object bean, String id) throws BeansException {
         // TODO Auto-generated method stub
         if(bean instanceof AImp){
              AImp aimp=(AImp)bean;
              aimp.setName(aimp.getName().toUpperCase());
         }
         return bean;
     }

     public Object postProcessBeforeInitialization(Object arg0, String arg1) throws BeansException {
         // TODO Auto-generated method stub
         return arg0;
     }

}

xml:

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



              yuchen







Test:
package yuchen.beanpostprocessor;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ClassPathXmlApplicationContext factory=new ClassPathXmlApplicationContext("yuchen/beanpostprocessor/beans.xml");
         A aa=(A) factory.getBean("a");
         aa.display();
     }

}

Spring 基础教程(一)

唧唧 — 2008-07-23 01:55:38.0

基本概念:
1.什么是spring?有什么用?
2.Spring和其他类似产品的区别?
3.Spring的特点(优缺点)?
4.Spring的内容?

什么是spring?有什么用?
Spring就是轻量级的业务层框架,什么是轻量级:第一,spring的文件大小只有1mb多,第二,资源消耗,占用内存与其他的产品相比较小(如:EJB)
作用:完成业务层的开发

Spring和其他类似产品的区别?
轻量级,EJB也是完成业务层的开发,但是他是重量级的框架,EJB的重点在企业应用,那么有些程序没有必要使用重量级的工具来开发轻量级的应用,这样成本过大,spring就是满足完成轻量级应用的业务层框架

Spring的特点(优缺点)?
优点:
1.依赖注入(控制反转):什么是依赖注入?在一个对象需要使用另一个对象的时候,只声明另一个对象的接口,它的实例在运行时获得它,作用:就是解决了组件中的耦合,也就是不依赖于固定的对象
2.面向方面编程:什么是面向方面编程?AOP:在预编译或运行时为程序加入新的功能(如:加入安全,同步,事务等),编程方式采用的是注释,不用在业务代码中写这些与业务无关的代码了,作用:实现业务与其他代码分离,解耦合,他完善依赖注入(DI)
3.简化javaee编程结构:对web的支持(MVC),DAO的支持,ORM的支持
4.类似一站式服务:web,业务的功能都有,用户也可以选择性的使用

Spring的内容?
1.核心模块:BeanFactory(用来管理bean组件的,相当于bean的容器,通过独bean的xml文件,可以从中知道bean与bean的依赖关系和bean的实现)
2.AOP:面向方面编程(声明式中间件服务管理)
3.ORM
4.DAO
5.Web
6.Context:ApplicationContext:作用:增强功能,如:程序国际化等

第一个Spring:
1.下载spring框架
2.解读spring框架的目录结构
3.实例1(不使用工具)
4.实例2(eclipse)
5.杂项问题

下载spring框架:
http://www.springframework.org
本地: E:\个人数据库\基本结构\专业\spring\参考资料\Spring-framework.zip

解读spring框架的目录结构:
解压下载的spring框架:
/dist:核心包,spring.jar(工厂文件集合),还有spring.jar的子包,spring-beans.dtd:定义beans.xml的属性和beans.xml的头部
/docs:spring api文档
/lib:spring的编译和运行所依赖的第三方类库

实例1(不使用工具):
程序目标:开发一个spring,功能是显示hello 方法参数 my name is bean属性value
1.设置classpath:添加spring.jar and \lib\jakarta-commons\commons-logging.jar
2.创建一个应用目录:yuchen
3.创建src目录
4.开发一个接口和一个类
5.写配置文件beans.xml:定义这个类,文件的头部可以去spring-beans.dtd中找到
6.写客户端测试类
7.编译运行

接口:
package first;

public interface Hello{
     public String sayhello(String user);
     }

Bean:
package first;

public class HelloImp implements Hello{
     private String name;
     public String sayhello(String user){
         return "hello, "+user+"my name is: "+this.name;
         }
     public void setName(String name){
         this.name=name;
         }
     }

Xml:

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



              spring



Test:
import org.springframework.core.io.ClassPathResource;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import first.*;

public class TestHello{

     public static void main(String [] args){
              //1.读取配置文件,beans.xml:注意beans.xml的写法:如果放到根目录
              //下,那么直接写beans.xml,如果放到子目录下,子目录名/beans.xml
              //2.实例化bean工厂对象,载入xml资源:工厂负责管理bean组件的
              //目前是管理当前xml资源中的bean
              //3.通过bean工厂对象得到你要找的bean实例
              ClassPathResource resource=new ClassPathResource("beans.xml");
              XmlBeanFactory factory=new XmlBeanFactory(resource);
              Hello hello=(Hello)factory.getBean("hello");
              String rst=hello.sayhello("yuchen");
              System.out.println(rst);
         }
     }

D:\yuchen> Javac –d d:\yuchen d:\yuchen\src\*.java
D:\yuchen> Javac –d d:\yuchen d:\yuchen\*.java
D:\yuchen> java TestHello

实例2(eclipse):
程序目标:测试spring的特性:依赖注入/控制反转,调用A类的业务方法,这个方法需要B类方法提供的数据,在A类中,没有B实例,只有B的接口类型,只依赖它的接口,在运行时获得B的实例,从而得到其数据
1.新建java工程
2.配置jar:两个包
3.开发两个接口,两个类
4.写beans.xml
5.测试类测试
Model接口:
package yuchen.beanfactory;

public interface Model {
     public String supportData();
}

View接口:
package yuchen.beanfactory;

public interface View {
     public void render();
}

Model bean:
package yuchen.beanfactory;

public class AcountModel implements Model {

     private String ownerName;
     private double balance;
     public String supportData() {
         // TODO Auto-generated method stub
         return "Acdount : \n"+"ownerName :"+this.ownerName+
         "\n balance :"+this.balance;
     }
     public void setBalance(double balance) {
         this.balance = balance;
     }
     public void setOwnerName(String ownerName) {
         this.ownerName = ownerName;
     }

}

View bean:
package yuchen.beanfactory;

public class CommandLineView implements View {

     private Model model;
     public void render() {
         // TODO Auto-generated method stub
         String rst=model.supportData();
         System.out.println(rst);
     }
     public void setModel(Model model) {
         this.model = model;
     }

}

beans.xml:

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



              tarena


              1000.56









test:
package yuchen.beanfactory;

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         ClassPathResource resource=new ClassPathResource("yuchen/beanfactory/beans.xml");
         XmlBeanFactory factory=new XmlBeanFactory(resource);
         View view=(View) factory.getBean("view");
         view.render();
     }

}

杂项问题:
1.在eclipse中引入xml dtd文件
Windows->preferences->web and xml -> xml catalog
Add:uri:要导入的dtd地址如:spring-beans.dtd
Key type:public id
Key:例如:-//spring//dtd//en

2.导入log4j
导入:spring/lib/log4j.jar
在根目录下创建log4j.properties文件,内容从H:\spring-framework-1.2.8\test\
log4j.properties里面拷贝
解决了运行中显示红色的log信息的问题

Spring Framework 2.5 Reference中文版正式发布

唧唧 — 2008-07-13 16:07:30.0

声明
Spring中文参考手册得到Spring Framework开发团队的直接授权和大力的支持，其目的是在中文世界推广优秀的开源技术。本次翻译活动由满江红开放技术研究组织(http://www.redsaga.com )和Spring中文论坛(http://spring.jactiongroup.net ) 共同发起、组织。我们在此郑重宣布，本次翻译遵循原Spring Framework的授权协议，即Apache 2.0协议。在完整保留全部文本(包括本版权页)，并且不违反Apache 2.0协议的前提下，允许和鼓励任何人进行全文转载及推广，所有参与人员放弃除署名权外的一切权利。

致谢
如此庞大的项目不是一两个组织可以独立完成的，就像Spring本身一样，涵盖了Java技术的方方面面。因为有了大家的关心和支持才使此次项目能够顺利完成。有理由相信，中文开源世界必将在不久的将来展现出更广阔的发展空间，希望大家都能为推动中国软件发展奉献出自己的一份力量。

项目主页：
http://wiki.redsaga.com/confluence/display/Spring2/Spring2.5
勘误表：
http://wiki.redsaga.com/confluence/pages/viewpage.action?pageId=3171

在线版本：HTML / HTML Single

下载地址：PDF(593页，4.41MB) / CHM(2.08MB)

勘误表：勘误表(Spring 2.5)

Spring Configuration电子书

amen — 2008-06-19 15:00:27.0

Spring Configuration是一本专门介绍Spring配置文件的好书，希望对大家有用！！
19_0257_71F9927.pdf