BlogJava-丄諦啲仇魜ヤ -文章分类-spring

如何在Spring中配置定时任务

Crying — Sun, 16 Mar 2008 10:31:00 GMT

原文：http://www.blogjava.net/amigoxie/archive/2008/02/29/183046.html

首先，如果你在web.xml文件中的配置是这样的：

        contextConfigLocation

         /WEB-INF/classes/applicationContext-*.xml

那么需要在工程下创建一个以applicationContext- 为开头的xml文件eg:applicationContext-jobconfig.xml

xml的头和结尾部分跟其他spring配置文件相似，就不赘述，正文如下：

类别名)" class="com.******.YourJobClassLocation(类的定位)" />
别名)" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

     类别名)""/>


     runMethodName(定时执行的方法名)


触发器别名)" class="org.springframework.scheduling.quartz.CronTriggerBean">

     别名)""/>


   0 0/20 * * * ?(定时的时间配置)

     触发器别名)"/>

这样的配置几本就可以运转了，但是有一个地方可能是你需要根据你的需求来确定的，那就是触发时间。

下面有一些关于时间配置的说明：

字段顺序	允许值	允许的特殊字符
秒	0-59	, - * /
分	0-59	, - * /
小时	0-23	, - * /
日期	1-31	, - * ? / L W C
月份	1-12 或者 JAN-DEC	, - * /
星期	1-7 或者 SUN-SAT	, - * ? / L C #
年（可选）	留空, 1970-2099	, - * /

The '*' character is used to specify all values. For example, "*" in the minute field means "every minute".
“*”字符被用来指定所有的值。如：”*“在分钟的字段域里表示“每分钟”。
The '?' character is allowed for the day-of-month and day-of-week fields. It is used to specify 'no specific value'. This is useful when you need to specify something in one of the two fileds, but not the other. See the examples below for clarification.
“?”字符只在日期域和星期域中使用。它被用来指定“非明确的值”。当你需要通过在这两个域中的一个来指定一些东西的时候，它是有用的。看下面的例子你就会明白。
月份中的日期和星期中的日期这两个元素时互斥的一起应该通过设置一个问号(?)来表明不想设置那个字段

The '-' character is used to specify ranges For example "10-12" in the hour field means "the hours 10, 11 and 12".
“-”字符被用来指定一个范围。如：“10-12”在小时域意味着“10点、11点、12点”。

The ',' character is used to specify additional values. For example "MON,WED,FRI" in the day-of-week field means "the days Monday, Wednesday, and Friday".
“,”字符被用来指定另外的值。如：“MON,WED,FRI”在星期域里表示”星期一、星期三、星期五”.

The '/' character is used to specify increments. For example "0/15" in the seconds field means "the seconds 0, 15, 30, and 45". And "5/15" in the seconds field means "the seconds 5, 20, 35, and 50". Specifying '*' before the '/' is equivalent to specifying 0 is the value to start with. Essentially, for each field in the expression, there is a set of numbers that can be turned on or off. For seconds and minutes, the numbers range from 0 to 59. For hours 0 to 23, for days of the month 0 to 31, and for months 1 to 12. The "/" character simply helps you turn on every "nth" value in the given set. Thus "7/6" in the month field only turns on month "7", it does NOT mean every 6th month, please note that subtlety.

"/"字符用来指定渐增的值。例如0/15出现在秒字段的时候意味着“在第0，15，30和45秒”（的时候被触发）。而5/15出现在秒字段的时候意味着“在第5，20，35和第50秒”（的时候被触发）。"*/"和"0/"的指定是等价的。

注：当分子+分母的值大于该字段的最大值，如在秒钟字段出现45/20的时候，表示在第45秒以后的每20会触发一次，但是20秒以后又算做另外的时间段以内了，所以该字段的/20即失效，如改为45/10 则只有第45 和55秒会执行一次。

The 'L' character is allowed for the day-of-month and day-of-week fields. This character is short-hand for "last", but it has different meaning in each of the two fields. For example, the value "L" in the day-of-month field means "the last day of the month" - day 31 for January, day 28 for February on non-leap years. If used in the day-of-week field by itself, it simply means "7" or "SAT". But if used in the day-of-week field after another value, it means "the last xxx day of the month" - for example "6L" means "the last friday of the month". When using the 'L' option, it is important not to specify lists, or ranges of values, as you'll get confusing results.

L是‘last’的省略写法可以表示day-of-month和day-of-week域，但在两个字段中的意思不同，例如day-of-month域中表示一个月的最后一天，
如果在day-of-week域表示‘7’或者‘SAT’，如果在day-of-week域中前面加上数字，它表示一个月的最后几天，例如‘6L’就表示一个月的最后一个
星期五，

The 'W' character is allowed for the day-of-month field. This character is used to specify the weekday (Monday-Friday) nearest the given day. As an example, if you were to specify "15W" as the value for the day-of-month field, the meaning is: "the nearest weekday to the 15th of the month". So if the 15th is a Saturday, the trigger will fire on Friday the 14th. If the 15th is a Sunday, the trigger will fire on Monday the 16th. If the 15th is a Tuesday, then it will fire on Tuesday the 15th. However if you specify "1W" as the value for day-of-month, and the 1st is a Saturday, the trigger will fire on Monday the 3rd, as it will not 'jump' over the boundary of a month's days. The 'W' character can only be specified when the day-of-month is a single day, not a range or list of days
.
The 'L' and 'W' characters can also be combined for the day-of-month expression to yield 'LW', which translates to "last weekday of the month".

The '#' character is allowed for the day-of-week field. This character is used to specify "the nth" XXX day of the month. For example, the value of "6#3" in the day-of-week field means the third Friday of the month (day 6 = Friday and "#3" = the 3rd one in the month). Other examples: "2#1" = the first Monday of the month and "4#5" = the fifth Wednesday of the month. Note that if you specify "#5" and there is not 5 of the given day-of-week in the month, then no firing will occur that month.

The 'C' character is allowed for the day-of-month and day-of-week fields. This character is short-hand for "calendar". This means values are calculated against the associated calendar, if any. If no calendar is associated, then it is equivalent to having an all-inclusive calendar. A value of "5C" in the day-of-month field means "the first day included by the calendar on or after the 5th". A value of "1C" in the day-of-week field means "the first day included by the calendar on or after sunday".
关于cronExpression的介绍:
　
字段允许值允许的特殊字符
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日期 1-31 , - * ? / L W C
月份 1-12 或者 JAN-DEC , - * /
星期 1-7 或者 SUN-SAT , - * ? / L C #
年（可选）留空, 1970-2099 , - * /
表达式意义
"0 0 12 * * ?" 每天中午12点触发
"0 15 10 ? * *" 每天上午10:15触发
"0 15 10 * * ?" 每天上午10:15触发
"0 15 10 * * ? *" 每天上午10:15触发
"0 15 10 * * ? 2005" 2005年的每天上午10:15触发
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发
"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发
"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发
"0 15 10 15 * ?" 每月15日上午10:15触发
"0 15 10 L * ?" 每月最后一日的上午10:15触发
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发
每天早上6点
0 6 * * *
每两个小时
0 */2 * * *
晚上11点到早上7点之间每两个小时，早上八点
0 23-7/2，8 * * *
每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点
0 11 4 * 1-3
1月1日早上4点
0 4 1 1 *

quartz的高级特性不仅如此
1 数据库存储
2 集群支持
3 数据库持久化任务，trigger
4 trigger 的停止，运行
5 任务的任意添加
6 比corntrigger 更详尽的任务安排
7 线程的内部数据交换

Crying 2008-03-16 18:31 发表评论

Spring的事务管理

Crying — Tue, 06 Nov 2007 06:56:00 GMT

转贴的地址忘记了对不起啊！

Spring的事务管理是经常用到的，论坛里已经不知讨论了多少变了。
记录下几个讲的比较清楚的。

spring事务探索
http://www.javaeye.com/topic/11190

解惑 spring 嵌套事务
http://www.javaeye.com/topic/35907?page=1

Spring声明式事务管理源码解读
http://www.javaeye.com/topic/87426?page=1

详解spring事务属性
http://www.javaeye.com/post/282638

附：事务的概念

一.原子性（Atomic）
事务由一个或多个行为组成，形成一个工作单元。原子性确保在这个工作单元中的所有操作要么都发生，要么都不发生。任何一个行为失败，整个事务就回滚。

二.一致性（Consistent）
一旦一个事务结束了，不管成功与否，系统所处状态和它的也为规则是一致的，就数据应当不会被破坏。

三.隔离性（Isolated）
事务应该允许多个用户操作同一个数据，但用户之间不会互相影响。因此，事务必须是隔离的，防止并发读写同一个数据的情况发生。

四.持久性（Durable）
一旦事务成功完成，事务的结果就应该被持久化下来。

Crying 2007-11-06 14:56 发表评论

AOP观念（转载）

Crying — Thu, 13 Sep 2007 11:33:00 GMT

AOP全名为Aspect-Oriented Programming，有关于AOP的许多名词术语都过于抽象，单从字面上并不容易理解其名词意义，这边将以之前介绍代理机制的范例来逐一对照以介绍AOP的术语与观念：

Cross-cutting concern

在DynamicProxyDemo项目的例子中，记录的动作原先被横切（Cross-cutting）入至HelloSpeaker本身所负责的业务流程之中，另外类似于记录这类的动作，如安全（Security）检查、事务（Transaction）等系统层面的服务（Service），在一些应用程序之中常被见到安插至各个对象的处理流程之中，这些动作在AOP的术语中被称之为Cross-cutting concerns。

以图片说明可强调出Cross-cutting concerns的意涵，例如原来的业务流程是很单纯的：

现在为了要加入记录（Logging）与安全（Security）检查等服务，对象的程序代码中若被硬生生的写入相关的Logging、Security程序片段，则可使用以下图解表示出Cross-cutting与Cross-cutting concerns的概念：

Cross-cutting concerns若直接撰写在负责某业务的对象之流程中，会使得维护程序的成本增高，例如若您今天要将对象中的记录功能修改或是移除该服务，则必须修改所有撰写曾记录服务的程序代码，然后重新编译，另一方面，Cross-cutting concerns混杂于业务逻辑之中，使得业务对象本身的逻辑或程序的撰写更为复杂。

Aspect

将散落于各个业务对象之中的Cross-cutting concerns收集起来，设计各个独立可重用的对象，这些对象称之为Aspect，例如在DynamicProxyDemo项目中将登录的动作设计为一个LogHandler类别，LogHandler类别在AOP的术语就是Aspect的一个具体实例，在AOP中着重于Aspect的辨认，将之从业务流程中独立出来，在需要该服务的时候，缝合（Weave）至应用程序之上，不需要服务的时候，也可以马上从应用程序中脱离，应用程序中的可重用组件不用作任何的修改，例如在DynamicProxyDemo项目中的HelloSpeaker所代表的角色就是应用程序中可重用的组件，在它需要记录服务时并不用修改本身的程序代码。

另一方面，对于应用程序中可重用的组件来说，以AOP的设计方式，它不用知道处理提供服务的对象之存在，具体的说，与服务相关的API不会出现在可重用的应用程序组件之中，因而可提高这些组件的重用性，您可以将这些组件应用至其它的应用程序之中，而不会因为目前加入了某些服务而与目前的应用程序框架发生耦合。

Advice

Aspect的具体实作称之为Advice，以记录的动作而言，Advice中会包括真正的记录程序代码是如何实作的，像是DynamicProxyDemo项目中的LogHandler类别就是Advice的一个具体实例，Advice中包括了Cross-cutting concerns的行为或所要提供的服务。

Joinpoint

Aspect在应用程序执行时加入业务流程的点或时机称之为Joinpoint，具体来说，就是Advice在应用程序中被呼叫执行的时机，这个时机可能是某个方法被呼叫之前或之后（或两者都有），或是某个例外发生的时候。

Pointcut

Pointcut是一个定义，藉由这个定义您可以指定某个Aspect在哪些Joinpoint时被应用至应用程序之上。具体的说，您可以在某个定义档中撰写Pointcut，当中说明了哪些Aspect要应用至应用程序中的哪些Joinpoint。

Target

一个Advice被应用的对象或目标对象，例如DynamicProxyDemo项目中的HelloSpeaker就是LogHandler这个Advice的Target。

Introduction

对于一个现存的类别，Introduction可以为其增加行为，而不用修改该类别的程序，具体的说，您可以为某个已撰写、编译完成的类别，在执行时期动态加入一些方法或行为，而不用修改或新增任何一行程序代码。

Proxy

在《Expert One-on-One J2EE Development WIthout EJB》一书中，Rod Johnson、Juergen Hoeller在第八章中有提到，AOP的实作有五个主要的策略：Dynamic Proxies、Dynamic Byte Code Generation、Java Code Generation、Use of a Custon Class Loader、Language Extensions。

在之前静态代理与动态代理中，已经使用实际的程序范例介绍过代理机制的实现，Spring的AOP主要是透过动态代理来完成。

Weave

Advice被应用至对象之上的过程称之为缝合（Weave），在AOP中缝合的方式有几个时间点：编译时期（Compile time）、类别加载时期（Classload time）、执行时期（Runtime）。

结合DynamicProxyDemo的实例，将以上介绍过的AOP相关名词具体的使用图片来加以表示，有助于您对每一个名词的理解与认识：

Crying 2007-09-13 19:33 发表评论

使用Spring邮件抽象层发送简单邮件(转http://www.blogjava.net/shmily432685/archive/2005/12/30/26041.html)

Crying — Tue, 04 Sep 2007 09:35:00 GMT

Spring提供了一个发送电子邮件的高级抽象层，它向用户屏蔽了底层邮件系统的一些细节，同时负责低层次的代表客户端的资源处理。Spring邮件抽象层的主要包为org.springframework.mail。它包括了发送电子邮件的主要接口MailSender和封装了简单邮件的属性如from, to,cc, subject, text的值对象叫做SimpleMailMessage。
1、我们定义一个发送邮件的接口:OrderManager.java

1 public interface OrderManager extends BaseManager{
2 /**
3 *email,要发送的邮件地址;
4 *Code:激活码
5 */
6 public void placeOrder(String email);
7 }

2、我们需要对该接口进行实现的方法:OrderManagerImpl.java

1 import javax.mail.Message;
2 import javax.mail.MessagingException;
3 import javax.mail.internet.InternetAddress;
4 import javax.mail.internet.MimeMessage;
5 import org.springframework.mail.MailException;
6 import org.springframework.mail.javamail.JavaMailSender;
7 import org.springframework.mail.javamail.MimeMessagePreparator;
8 import service.OrderManager;
9
11 public class OrderManagerImpl extends BaseManagerImpl implements OrderManager {
12
13 private JavaMailSender mailsender;
14 private MyMailMessage message;
15
16
17     public void setMessage(CityMailMessage message)
18     {
19         this.message = message;
20     }
21     public void setMailsender(JavaMailSender mailsender) {
22         this.mailsender = mailsender;
23     }
24     public void placeOrder(final String email) {
25
26
27         MimeMessagePreparator preparator = new MimeMessagePreparator() {
28             public void prepare(MimeMessage mimeMessage) throws MessagingException {
29                 mimeMessage.setRecipient(Message.RecipientType.TO,
30                         new InternetAddress(email));
31                 mimeMessage.setFrom(new InternetAddress(message.getFrom()));
32                 /**转换编码为GBK*/
33                 mimeMessage.setSubject(message.getSubject(),"GBK");
36                 mimeMessage.setText(email+"
"+message.getSubject()+message.getText(),"GBK");
37
38             }
39         };
40         try{
41             mailsender.send(preparator);
42         }
43         catch(MailException ex) {
44             //log it and go on
45             System.err.println(ex.getMessage());
46         }
47     }
48 }

3、spring配置发送email的applicationContext-email.xml

1 xml version="1.0" encoding="UTF-8"?>
2 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
3     "http://www.springframework.org/dtd/spring-beans.dtd">
4
5 <beans>
6     <bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
7         <property name="host">
8             <value>smtp.163.comvalue>
9         property>
10         <property name="username">
11             <value>usernamevalue>
12         property>
13         <property name="password">
14             <value>passwordvalue>
15         property>
16         <property name="javaMailProperties">
17             <props>
18                 <prop key="mail.smtp.auth">trueprop>
19                 <prop key="mail.smtp.timeout">25000prop>
20             props>
21         property>
22     bean>
23
24     <bean id="mailMessage" class="org.springframework.mail.SimpleMailMessage">
25         <property name="from">
26             <value>Emailvalue>
27         property>
28         <property name="subject">
29             <value>标题value>
30         property>
31         <property name="text">
32             <value>内容
33         property>
46     bean>
47
48     <bean id="orderManager" class="cn.cityyouth.service.impl.OrderManagerImpl">
49         <property name="mailsender">
50             <ref bean="mailSender" />
51         property>
52         <property name="message">
53             <ref bean="mailMessage" />
54         property>
55     bean>
56
57 beans>

4、最后配置自己的jsp页面以及action

1 package cn.cityyouth.web.action;
2
3 import javax.servlet.http.HttpServletRequest;
4 import javax.servlet.http.HttpServletResponse;
5 import org.apache.struts.action.ActionForm;
6 import org.apache.struts.action.ActionForward;
7 import org.apache.struts.action.ActionMapping;
8 import org.apache.struts.action.ActionMessage;
9 import org.apache.struts.action.ActionMessages;
10 import com.test.service.OrderManager;
11
12 public class SendMailAction extends BaseAction {
13
14     /**
15      * Method execute
16      *
17      * @param mapping
18      * @param form
19      * @param request
20      * @param response
21      * @return ActionForward
22      */
23     public ActionForward execute(ActionMapping mapping, ActionForm form,
24             HttpServletRequest request, HttpServletResponse response) {
25         OrderManager omi=(OrderManager)this.getBean("orderManager");
26         String useremail="123@163.com";
27          omi.placeOrder(useremail);
28        }
29 }

到此所有的开发以结束。

Sring邮件抽象层的主要包是：org.springframework.mail 包。它包含叫MailSender为发送邮件的核心接口和包含简单邮件属性例如from,to,cc,subject,text叫SimpleMailMessage的值对象. 这个包也包含一个检查异常的层次，它支持一个更高级别的抽象超过低级别的邮件系统异常伴随根异常存在MailException. 请参考JavaDocs为更多的信息杂邮件异常层次。

spring in action in action also provides a sub-interface of MailSender for specialized JavaMail features such as MIME messages, namely org.springframework.mail.javamail.JavaMailSender It also provides a callback interface for preparation of JavaMail MIME messages, namely org.springframework.mail.javamail.MimeMessagePreparator

Spring也支持一个MailSender的专用于JavaMail特征例如MIME消息子接口，命名为org.springframework.javamail.JavaMailerSener。它也支持一个为JavaMail MIME信息的准备回调接口，命名为org.springframework.mail.JavaMail.MimeMessagePreparator.

Crying 2007-09-04 17:35 发表评论

Spring IOC

Crying — Sun, 02 Sep 2007 01:10:00 GMT

假设我们要设计一个Girl和一个Boy类，其中Girl有kiss方法，即Girl想要Kiss一个Boy。那么，我们的问题是，Girl如何能够认识这个Boy？

在我们中国，常见的MM与GG的认识方式有以下几种

1 青梅竹马； 2 亲友介绍； 3 父母包办

那么哪一种才是最好呢？

青梅竹马：Girl从小就知道自己的Boy。

public class Girl {

void kiss(){

Boy boy = new Boy();

}

然而从开始就创建的Boy缺点就是无法在更换。并且要负责Boy的整个生命周期。如果我们的Girl想要换一个怎么办？（严重不支持Girl经常更换Boy,#_#）

亲友介绍：由中间人负责提供Boy来见面

public class Girl {

void kiss(){

Boy boy = BoyFactory.createBoy();

}

亲友介绍，固然是好。如果不满意，尽管另外换一个好了。但是，亲友BoyFactory经常是以Singleton的形式出现，不然就是，存在于Globals，无处不在，无处不能。实在是太繁琐了一点，不够灵活。我为什么一定要这个亲友掺和进来呢？为什么一定要付给她介绍费呢？万一最好的朋友爱上了我的男朋友呢？

父母包办：一切交给父母，自己不用费吹灰之力，只需要等着Kiss就好了。

public class Girl {

void kiss(Boy boy){

// kiss boy

boy.kiss();

}

Well，这是对Girl最好的方法，只要想办法贿赂了Girl的父母，并把Boy交给他。那么我们就可以轻松的和Girl来Kiss了。看来几千年传统的父母之命还真是有用哦。至少Boy和Girl不用自己瞎忙乎了。

这就是IOC，将对象的创建和获取提取到外部。由外部容器提供需要的组件。

我们知道好莱坞原则：“Do not call us, we will call you.” 意思就是，You, girlie, do not call the boy. We will feed you a boy。

我们还应该知道依赖倒转原则即 Dependence Inversion Princinple，DIP

Eric Gamma说，要面向抽象编程。面向接口编程是面向对象的核心。

组件应该分为两部分，即 Service, 所提供功能的声明 Implementation, Service的实现

好处是：多实现可以任意切换，防止 “everything depends on everything” 问题．即具体依赖于具体。

所以，我们的Boy应该是实现Kissable接口。这样一旦Girl不想kiss可恶的Boy的话，还可以kiss可爱的kitten和慈祥的grandmother。

Crying 2007-09-02 09:10 发表评论

Spring简介

Crying — Sun, 02 Sep 2007 01:08:00 GMT

Spring 框架

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

图 1. Spring 框架的 7 个模块

组成 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 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境（Web 或 EJB）、独立应用程序、测试环境之间重用。

IOC 和 AOP

控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器（在 Spring 框架中是 IOC 容器）负责将这些联系在一起。

在典型的 IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。下表列出了 IOC 的一个实现模式。

类型 1服务需要实现专门的接口，通过接口，由对象提供这些服务，可以从对象查询依赖性（例如，需要的附加服务）类型 2通过 JavaBean 的属性（例如 setter 方法）分配依赖性类型 3依赖性以构造函数的形式提供，不以 JavaBean 属性的形式公开

Spring 框架的 IOC 容器采用类型 2 和类型3 实现。

面向方面的编程

面向方面的编程，即 AOP，是一种编程技术，它允许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化。AOP 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中。

AOP 和 IOC 是补充性的技术，它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中，可能要将日志记录语句放在所有方法和 Java 类中才能实现日志功能。在 AOP 方式中，可以反过来将日志服务模块化，并以声明的方式将它们应用到需要日志的组件上。当然，优势就是 Java 类不需要知道日志服务的存在，也不需要考虑相关的代码。所以，用 Spring AOP 编写的应用程序代码是松散耦合的。

AOP 的功能完全集成到了 Spring 事务管理、日志和其他各种特性的上下文中。

IOC 容器

Spring 设计的核心是 org.springframework.beans 包，它的设计目标是与 JavaBean 组件一起使用。这个包通常不是由用户直接使用，而是由服务器将其用作其他多数功能的底层中介。下一个最高级抽象是 BeanFactory 接口，它是工厂设计模式的实现，允许通过名称创建和检索对象。BeanFactory 也可以管理对象之间的关系。

BeanFactory 支持两个对象模型。

单态模型提供了具有特定名称的对象的共享实例，可以在查询时对其进行检索。Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很理想。原型模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，原型模型最适合。 bean 工厂的概念是 Spring 作为 IOC 容器的基础。IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个示例中演示的那样，Spring 框架使用 JavaBean 属性和配置数据来指出必须设置的依赖关系。

Crying 2007-09-02 09:08 发表评论