Spring框架简介
原文地址：https://www.wendangku.net/doc/a53098734.html,/myriads/blog/37922
Spring框架简介
1、使用框架的意义与Spring的主要内容
随着软件结构的日益庞大，软件模块化趋势出现，软件开发也需要多人合作，随即分工出现。如何划分模块，如何定义接口方便分工成为软件工程设计中越来越关注的问题。良好的模块化具有以下优势：可扩展、易验证、易维护、易分工、易理解、代码复用。
优良的模块设计往往遵守“低耦合高内聚”的原则。而“框架”是对开发中良好设计的总结，把设计中经常使用的代码独立出来，所形成的一种软件工具。用户遵守它的开发规则，就可以实现良好的模块化，避免软件开发中潜在的问题。广义上的框架无处不再，一个常见的例子就是PC硬件体系结构，人们只要按照各自需要的主板、显卡、内存等器件就可以任意组装成自己想要的电脑。而做主板的厂商不用关心做显卡厂商的怎么实现它的功能。软件框架也是如此，开发人员只要在Spring框架中填充自己的业务逻辑就能完成一个模块划分清晰纷的系统。
这里主要通过一个银行通知用户月收支记录的小例子来介绍轻型J2EE框架Spring的主要内容、它所解决的问题和实现的方法。
Spring框架主要可以分为3个核心内容：
1、容器
2、控制反转（IoC ，Inversion of Control）
3、面向切面编程（AOP ，Aspect-Oriented Programming）
例子中依次对这些特性进行介绍，描述了软件模块化后存在的依赖与问题，以及Spring框架如何解决这些问题。
2、一个简单的例子程序
假设有一个如下应用场景：（1）一个银行在每月的月初都需要向客户发送上个月的账单，账单发送的方式可以为纸质邮寄、或者短信方式。（2）还有一个潜在的需求：为了安全起见，在每个函数操作过程中都需要记录日志，记录参数传入是否正常，函数是否正常结束，以便出错时系统管理员查账。
那么对这个需求进行简单实现。系统框图如下所示：
首先定义一个账单输出的接口：
//接口
public interface ReportGenerator{
public void generate(String[][] table) ;
}
实现“打印纸质账单”与“发送短信”两个具体功能：
//账单报表实现类
public class PageReportGenerator implement ReportGenerator {
public void generate(String[][] table) {
https://www.wendangku.net/doc/a53098734.html,( ... ); //输出日志
...打印操作，以便工作人员邮递给客户
https://www.wendangku.net/doc/a53098734.html,( ... ); //输出日志
}
}
//短信报表实现类
public class SMSReportGenerator implement ReportGenerator {
public void generate(String[][] table) {
https://www.wendangku.net/doc/a53098734.html,( ... );
...短信发送操作
https://www.wendangku.net/doc/a53098734.html,( ... );
}
}
上层业务逻辑对上个月的账目进行统计并调用接口产生纸质或者短信结果：
//上层业务中的服务类
public class ReportService{
private ReportGenerator reportGenerator = new SMSReportGenerator();
public void generateMonthlyReport(int year, int month) {
https://www.wendangku.net/doc/a53098734.html,( ... );
String[][] statistics = null ;
...
reportGenerator.generate(statistics);
}
}
这个实现源代码请查看文章结尾附录中的"BankOld"。源代码中与例子中程序略有区别：由于使用log4j需要引用外部的包，并且需要写配置文件，为了方便，源代码中的日志输出用system.out.println()代替。
3、Spring中的容器
A、模块化后出现的问题与隐患
假设随着工程的复杂化，上面的例子需要分成两个模块，以便开发时分工，一般会以如下结构划分：
划分后再看原来的代码：
//上层业务中的服务类
public class ReportService{
private ReportGenerator reportGenerator = new SMSReportGenerator(); //隐患
public void generateMonthlyReport(int year, int month) {
...
}
}
在服务类有private ReportGenerator reportGenerator = new SMSReportGenerator();这么一行代码，ReportService类与SMSReportGenerator类不属于同一个模块，当开发人员B对内部实现进行修改时，由于存在依赖，开发人员A也要进行修改（比如之前喜欢短信收账单的客户感觉短信不够详细，希望以后改用邮件收账单，那么开发人员B需要实现一个MailReportGenerator类，在开发人员B修改代码时，开发人员A也需要改代码------声明部分修改）。如果系统庞大new
SMSReportGenerator()大量使用的话，修改就会十分复杂，一个声明没有修改就会出现大的BUG。
所以需要一种划分，让各个模块尽可能独立，当开发人员B修改自己的模块时，开发人员A不需要修改任何代码。
B、问题出现的原因
为例子中的程序画一个UML依赖图
可以发现上问题出现的原因主要是：模块A与模块B不但存在接口依赖，还存在实现依赖。ReportGenerator每次修改它的实现，都会对ReportService产生影响。那么需要重构消除这种实现依赖。
C、用容器解决问题
消除实现依赖一般可以通过添加一个容器类来解决。在例子程序容器代码如下：
//容器类
public class Container {
public static Container instance;
private Map
public Container(){
component = new HashMap
instance = this;
ReportGenertor reportGenertor = new SMSReportGenertor();
components.put(“reportGenertor”, reportGenertor);
ReportService reportService = new ReportService();
components.put(“reportService”, reportService);
}
public Object getComponent(String id){
return components.get(id);
}
}
使用容器后，模块A的ReportService的属性实现方法也发生了变化。
//服务类变更，降低了耦合
public class ReportService{
//private ReportGenerator reportGenerator = new SMSReportGenerator();
private ReportGenerator reportGenerator = (ReportGenerator) Container.instance.getComponent(“reportGenerator”);
public void generateMonthlyReport(int year, int month) {
...
}
}
这样的话，class都在容器中实现，使用者只需要在容器中查找需要的实例，开发人员修改模块B后（在模块中增加邮件报表生成类MailReportGenerator），只需要在容器类中修改声明（把ReportGenertor
reportGenertor = new SMSReportGenertor();改为ReportGenertor reportGenertor = new MailReportGenertor();）即可，模块A不需要修改任何代码。一定程度上降低了模块之间的耦合。
4、Spring中的控制反转
A、还存在的耦合
使用容器后模块A与模块B之间的耦合减少了，但是通过UML依赖图可以看出模块A 开始依赖于容器类：
之前的模块A对模块B的实现依赖通过容器进行传递，在程序中用(ReportGenerator) Container.instance.getComponent(“reportGenerator”)的方法取得容器中SMSReportGenertor 的实例，这种用字符(“reportGenerator”)指代具体实现类SMSReportGenertor 的方式并没有完全的解决耦合。所以在银行账单的例子中我们需要消除ReportService对容器Container 的依赖。
B、控制反转与依赖注入
在我们常规的思维中，ReportService需要初始化它的属性private ReportGenerator reportGenerator就必须进行主动搜索需要的外部资源。不使用容器时，它需要找到SMSReportGenertor()的构造函数；当使用容器时需要知道SMSReportGenertor实例在容器中的命名。无论怎么封装，这种主动查找外部资源的行为都必须知道如何获得资源，也就是肯定存在一种或强或弱的依赖。那是否存在一种方式，让ReportService不再主动初始化reportGenerator，被动的接受推送的资源?
这种反转资源获取方向的思想被称为控制反转（IoC，Inversion of Control），使用控制反转后，容器主动地将资源推送给需要资源的类（或称为bean）ReportService，而ReportService需要做的只是用一种合适的方式接受资源。控制反转的具体实现过程用到了依赖注入（DI，Dependecncy Injection）的设计模式，ReportService类接受资源的方式有多种，其中一种就是在类中定义一个setter方法，让容器将匹配的资源注入：setter的写法如下：
//为需要依赖注入的类加入一种被称为setter的方法
public class ReportService{
/*private ReportGenerator reportGenerator =
(ReportGenerator) Container.instance.getComponent(“reportGenerator”); */
private ReportGenerator reportGenerator;
public void setReportGenerator( ReportGenerator reportGenerator) {
this.reportGenerator = reportGenerator;
}
public void generateMonthlyReport(int year, int month) {
...
}
}
在容器中把依赖注入：
//容器类
public class Container {
...
public Container ( ) {
component = new HashMap
instance = this;
ReportGenertor reportGenertor = new SMSReportGenertor();
components.put(“reportGenertor”, reportGenertor);
ReportService reportService = new ReportService();
reportService.setReportGenerator(reportGenerator); //使用ReportService的setter方法注入依赖关系
components.put(“reportService”, reportService);
}
...
}
这样一来ReportService就不用管SMSReportGenertor在容器中是什么名字，模块A对于模块B只有接口依赖，做到了松耦合。
C、Spring IoC容器的XML配置
每个使用Spring框架的工程都会用到容器与控制反转，为了代码复用，Spring把通用的代码独立出来形成了自己的IoC容器供开发者使用：
与上面例子中实现的容器相比，Spring框架提供的IoC容器要远远复杂的多，但用户不用关心Spring
IoC容器的代码实现，Spring提供了一种简便的bean依赖关系配置方式------使用XML文件，在上面的例子中，配置依赖关系只要在工程根目录下的“application.xml”编辑如下内容：
xmlns:xsi="https://www.wendangku.net/doc/a53098734.html,/2001/XMLSchema-instance" xmlns:p="https://www.wendangku.net/doc/a53098734.html,/schema/p" xsi:schemaLocation="https://www.wendangku.net/doc/a53098734.html,/schema/beans https://www.wendangku.net/doc/a53098734.html,/schema/beans/spring-beans-3.0.xsd" >
是标准的XML头，xmlns引用的是一些命名空间，两个一般在工程中自动生成。后面的内容由用户输入，主要表示实例化SMSReportGenerator，实例化ReportService并把SMSReportGenerator的对象smsReportGenerator赋值给ReportService的属性reportGenerator，完成依赖注入。
5、Spring中的面向切面编程
A、日志问题以及延伸
在例子的需求中有一条是：需要记录日志，以便出错时系统管理员查账。回顾例子中的代码，在每个方法中都加了日志操作：
//服务类
public class ReportService{
...
public void generateMonthlyReport(int year, int month) {
https://www.wendangku.net/doc/a53098734.html,( ... ); //记录函数的初始状况参数等信息
String[ ][ ] statistics = null ;
...
reportGenerator.generate(statistics);
https://www.wendangku.net/doc/a53098734.html,( ... ); //记录函数的执行状况与返回值
}
}
//凭条报表实现类
public class PageReportGenerator implement ReportGenerator {
public void generate(String[ ][ ] table) {
https://www.wendangku.net/doc/a53098734.html,( ... ); //记录函数的初始状况参数等信息
…打印操作
https://www.wendangku.net/doc/a53098734.html,( ... ); //记录函数的执行状况与返回值
}
}
可以看出在每个方法的开始与结尾都调用了日志输出，这种零散的日志操作存在着一些隐患，会导致维护的困难。比如日志输出的格式发送了变化，那么无论模块A还是模块B 的程序员都要对每个方法每个输出逐条修改，极容易遗漏，造成日志输出风格的不一致。又比如不用Log4j日志输出工具更换其他工具，如果遗漏一个将会出现严重BUG。
与日志输出相似的问题在编程中经常遇到，这种跨越好几个模块的功能和需求被称为横切关注点，典型的有日志、验证、事务管理等。
横切关注点容易导致代码混乱、代码分散的问题。而如何将很切关注点模块化是本节的重点。
B、代理模式
传统的面向对象方法很难实现很切关注点的模块化。一般的实现方式是使用设计模式中的代理模式。代理模式的原理是使用一个代理将对象包装起来，这个代理对象就取代了原有对象，任何对原对象的调用都首先经过代理，代理可以完成一些额外的任务，所以代理模式能够实现横切关注点。
可能在有些程序中有很多横切关注点，那么只需要在代理外再加几层代理即可。以银行账单为例介绍一个种用Java Reflection API动态代理实现的横切关注点模块化方法。系统提供了一个InvocationHandler接口：
//系统提供的代理接口
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throw Throwable;
}
我们需要实现这个接口来创建一个日志代理，实现代码如下：
//日志代理实现
public class LogHandler implement InvocationHandler{
private Object target;
public LogHandler(Object target){
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args ) throw Throwable{
//记录函数的初始状况参数等信息
https://www.wendangku.net/doc/a53098734.html,(“开始:方法”+ method.getName() + “参数”+Arrays.toString(args) );
Object result = method.invoke(target, args);
//记录函数的执行状况与返回值
https://www.wendangku.net/doc/a53098734.html,(“结束:方法”+ method.getName() + “返回值”+ result );
}
}
这样既可以使得日志操作不再零散分布于各个模块，易于管理。调用者可以通过如下方式调用：
//主函数
public class Main{
public static void main(String[ ] args){
ReportGenerator reportGeneratorImpl = new SMSReportGenerator ();
//通过系统提供的Proxy.newProxyInstance创建动态代理实例
ReportGenerator reportGenerator = (ReportGenerator ) Proxy.newProxyInstance( reportGeneratorImpl.getClass().getClassLoader(),
reportGeneratorImpl.getClass().getInterfaces(),
new LogHandler(reportGeneratorImpl)
) ;
...
}
}
代理模式很好的实现了横切关注点的模块化，解决了代码混乱代码分散问题，但是我们可以看出用Java Reflection API 实现的动态代理结构十分复杂，不易理解，Spring框架利用了代理模式的思想，提出了一种基于JAVA注解（Annotation）和XML配置的面向切面编程方法（AOP ，Aspect-Oriented Programming）简化了编程过程。
C、Spring AOP 使用方法
Spring AOP使用中需要为横切关注点（有些时候也叫切面）实现一个类，银行账单的例子中，切面的实现如下：
//切面模块实现
@Aspect //注解1
public class LogAspect{
@Before(“execution(* *.*(..))”) //注解2
public void LogBefore(JoinPoint joinPoint) throw Throwable{
https://www.wendangku.net/doc/a53098734.html,(“开始:方法”+ joinPoint.getSignature().getName() );
}
@After(“execution(* *.*(..))”) //注解3
public void LogAfter(JoinPoint joinPoint) throw Throwable{
https://www.wendangku.net/doc/a53098734.html,(“结束:方法”+ joinPoint.getSignature().getName() );
}
}
注解1表示这个类是一个切面，注解2中" * *.*(..)* "是一个通配符，表示在容器中所有类里有参数的方法。@Before(“execution(* *.*(..))”)表示在所有类里有参数的方法前调用切面中德LogBefore() 方法。同理，注解3中@After(“execution(* *.*(..))”)表示在所有类里有参数的方法执行完后调用切面中的LogAfter()方法。
实现完切面类后，还需要对Spring工程中的application.xml进行配置以便实现完整的动态代理：
xmlns:xsi="https://www.wendangku.net/doc/a53098734.html,/2001/XMLSchema-instance" xmlns:p="https://www.wendangku.net/doc/a53098734.html,/schema/p" xmlns:aop="https://www.wendangku.net/doc/a53098734.html,/schema/aop" xsi:schemaLocation="https://www.wendangku.net/doc/a53098734.html,/schema/beans https://www.wendangku.net/doc/a53098734.html,/schema/beans/spring-beans-3.0.xsd https://www.wendangku.net/doc/a53098734.html,/schema/aop https://www.wendangku.net/doc/a53098734.html,/schema/aop/spring-aop-3.0.xsd" >
这比之前IoC依赖关系配置的XML文件多了：xmlns:aop=https://www.wendangku.net/doc/a53098734.html,/schema/aop；https://www.wendangku.net/doc/a53098734.html,/schema/aop；https://www.wendangku.net/doc/a53098734.html,/schema/aop/spring-aop-3.0.xsd
这3个主要是声明XML中用于AOP的一些标签，
6、Spring总结
银行月账单报表例子通过使用Spring框架后变成了如下结构：
在Spring框架的基础上原来存在耦合的程序被分成松耦合的三个模块。无论那个模块修改，对其他模块不需要额外改动。这就完成了一种良好的架构，使软件易理解，模块分工明确，为软件的扩展、验证、维护、分工提供了良好基础。这就是Spring框架作用。当然Spring除了容器、控制反转、面向切面之外还有许多其他功能，但都是在这三个核心基础上实现的。
Spring简介
spring 年编著的《Expert one to one J2EE design and development
Spring Logo 书中，对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是一个开源框架，它由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相关jar包简介
spring相关jar包简介 spring.jar是包含有完整发布的单个jar包，spring.jar中包含除了 spring-mock.jar 里所包含的内容外其它所有jar包的内容，因为只有在开发环境下才会用到 spring-mock.jar来进行辅助测试，正式应用系统中是用不得这些类的。 除了spring.jar文件，Spring还包括有其它13个独立的jar包，各自包含着对应的Spring组件，用户可以根据自己的需要来选择组合自己的jar包，而不必引入整个spring.jar的所有类文件。 (1) spring-core.jar 这个jar文件包含Spring框架基本的核心工具类，Spring其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。 (2) spring-beans.jar 这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring- beans.jar文件就可以了。 (3) spring-aop.jar 这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。 (4) spring-context.jar 这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI所需的全部类，UI方面的用来与模板（Templating）引擎如Velocity、FreeMarker、JasperReports集成的类，以及校验Validation方面的相关类。 (5) spring-dao.jar 这个jar文件包含Spring DAO、Spring Transaction进行数据访问的所有类。为了使用声明型事务支持，还需在自己的应用里包含spring-aop.jar。 (6) spring-hibernate.jar 这个jar文件包含Spring对Hibernate 2及Hibernate 3进行封装的所有类。 (7) spring-jdbc.jar 这个jar文件包含对Spring对JDBC数据访问进行封装的所有类。 (8) spring-orm.jar 这个jar文件包含Spring对DAO特性集进行了扩展，使其支持iBATIS、JDO、OJB、TopLink，因为Hibernate已经独立成包了，现在不包含在这个包里了。这个jar文件里大部分的类都要依赖spring-dao.jar里的类，用这个包时你需要同时包含spring-dao.jar 包。
spring框架
spring框架 Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 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 Boot介绍和使用
【黑马程序员】Spring Boot介绍和使用 简介：Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。Spring Boot是一种简化原有Spring应用繁杂配置的微框架。使开发者从繁杂的各种配置文件中解脱出来，通过Spring Boot能够很简单、很快速构建一个优秀的、产品级的Spring基础应用。运行Spring Boot和运行普通的Java 类一样简单，仅仅run一下Spring Boot的入口main()方法即可开启应用；你也可以把Spring Boot应用打成jar，在命令行执行java -jar xxx.jar命令来运行；或者打成war包部署到服务器下运行服务器来开启应用。Spring Boot微框架考虑到了Spring平台和第三方库的情况，所以你需要做的则是最少的操作或配置。 Spring Boot的特点： 1. 创建独立的Spring应用程序 2. 嵌入的Tomcat，无需部署WAR文件 3. 简化Maven配置 4. 自动配置Spring 5. 绝对没有代码生成并且对XML也没有配置要求 Spring boot的使用 1.在ide中打开工程，这里使用的ide是idea，工程的目录结构为： 2、maven配置文件
一个非常有趣的使用spring框架AOP例子
一个非常有趣的使用spring框架AOP例子 接触spring有一段时间了，不过都是看的多，写的少，工作忙，公司也不准备用。自己写过一些小东西用到，也只用到了BeanFactory组装对象，JdbcTemplate代替jdbc，事务管理。。。东抓一把，西抓一把，没形成系统。最近也在看spring自带的reference，一时手痒，写了个AOP的创建advice的例子，比之单纯地使用TransationProxyFactoryBean 对AOP的理解又深入了点，打算看看它的源代码，基于CGLIB的实现对类的代理不了解，倒是好奇它如何实现对接口的代理??也就是利用J2SE的动态代理技术。 例子如下：讲述一间书店开始打折促销，规则是每一名顾客只能买一本书，而且已经脱销了。。。。。你可以去掉TestAdvice里的注释看看各种运行结果，具体就不解释咯，在代码注释里。 首先，你必须对增强(advice)有所了解，增强就是在特定连接点执行的动作。advice contains the logic of your aspect。增强，分为4类： 前增强(before)在连接点之前调用 后增强(after)在连接点执行之后调用、 环绕增强(around)完整控制整个方法流程，必须调用MethodInvocation的proceed促使真实操作发生 异常增强针对某个异常抛出时调用 书店，一个buyBook业务： package com.denny_blue.springdemo.aop; public interface BuyBook { public void buyBook(String customer,String book)throws NoThisBookException; } 实现此接口的一个业务对象，如果顾客要买就抛出NoThisBookException异常。 package com.denny_blue.springdemo.aop; public class MyBuyBook implements BuyBook { public void buyBook(String customer,String book)throws NoThisBookException{ if(book.equals("")) throw new NoThisBookException("对不起，没有"+book+"存货了！"); System.out.println(customer+",你好，你已经购买了一本"+book+"!"); } }
多图详解Spring框架的设计理念与设计模式
Spring作为现在最优秀的框架之一，已被广泛的使用，51CTO也曾经针对Spring框架中的JDBC应用做过报道。本文将从另外一个视角试图剖析出Spring框架的作者设计Spring框架的骨骼架构的设计理念。 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简介 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）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。 ◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。 ◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将
Spring技术介绍
一、基本概念 Spring 的核心是轻量级（Lightweight ）的容器（Container ），它实现了IoC 容器、非侵入性（No intrusive ）的框架，并提供AOP 概念的实现方式，提供对持久层（Persistence ）、事务（Transaction ）的支持，提供MVC Web 框架的实现，并对一些常用的企业服务API （Application Interface ）提供一致的模型封装，是一个全方位的应用程序框架（Application framework ），另外，Spring 也提供了对现有框架（Struts 、JSF 、Hibernate 等）的整合方案。 Spring 旨在分离体系结构的层次，因此每一层都可以修改而不会影响到其它层。每一层都不知道其上层的关注点；就其可能而言，只对所紧挨的下一层有依赖。层与层之间的依赖通常是以接口的形式表现，以确保其耦合尽可能松散。 容器管理事务，容器，贯穿始终：1、对象生命周期的管理。 2、容器本身具备功能，加在自己的类中。需要自己调用则为显示调用。 而尽量用容器隐式调用，Spring 即为隐式 对现有表现层的支持 与ORM 紧密结合，可使用声明式事务管理 AOP 标准接口的实 现（容器管理的声 明式的种种事务） 对JDBC 采用模板回调；声明的JDBC 事务管理. 提供了Bean 工厂 对Bean 工厂的扩 展（比如对事务、国际化的支持） 自己的MVC 实现
调用、声明式编程。 Spring 轻量级容器体现在：只需设置一个Jar 文件到CLASSPATH ，不用去调用它，但又可以拥有其强大的功能。组件的极大程度的复用。 让层与层中耦合度低——Loosely-Coupled 工厂类创建DAO 对象。 声明式编程：在xml 文件中声明。 基于POJO 类，支持事务，事务是根本；而EJB 事务由Container 管理。 Spring 将 View 层与持久层，比如与Hibernate 联系起来。Spring 简化Hibernate 的使用，还可以帮助管理Hibernate 。Spring 本身没有O-R_mapping ，因为有Hibernate ，她已经做得很好了。 Spring 将编译时异常（checked ）转化为运行时异常（runtime ）。比如，JDBC 则为编译时异常，即必须写try…catch ；而Hibernate 程序为运行时异常。 在spring-framework-2.0.5\dist 目录下 有jar 文件、 dtd 文件、 tld 文件。 总之，Spring 是一个轻型容器（light-weight container ），其核心是Bean 工厂（Bean Factory ），用以构造我们所需要的M （Model ）。在此基础之上，Spring 提供了AOP （Aspect-Oriented Programming, 面向层面的编程）的实现，用它来提供非管理环境下申明方式的事务、安全等服务；对Bean 工厂的扩展ApplicationContext 更加方便我们实现Java EE 的应用；DAO/ORM 的实现方便我们进行数据库的开发；Web MVC 和Spring Web 提供了Java Web 应用的框架或与其它流行的Web 框架进行集成。 二、IoC （Inversion of Control ） 1、定义：组件．．之间的依赖关系．．．．由容器．．在运行时决定。 例如：B 对象所依赖的A 对象是由 Spring 创建好并且通过Set 方法传递注入过来的。 最基本的优点体现在：若A 为接口，让B 依赖于接口。只看接口不管实现类。 可把工厂类全部替换掉。对象均为容器创建。到时还能把容器的功能融入到其中。 IoC 要求：容器尽量不要侵入到应用程序中去，应用程序本身可以依赖于抽象的接口， 容器根据这些接口所需要的资源注入到应用程序中，也就是说应用程序不会主动向容器 JavaBean 调用/包含 Spring 控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系。
Spring中文开发详细手册
Spring开发教程 Spring教程 (1) Spring框架概述 (2) Spring是什么？ (2) Spring的历史 (3) Spring的使命（Mission Statement） (3) Spring受到的批判 (3) Spring包含的模块 (4) 总结 (5) Spring的IoC容器 (6) 用户注册的例子 (6) 面向接口编程 (7) （用户持久化类）重构第一步——面向接口编程 (8) 重构第二步——工厂（Factory）模式 (9) 重构第三步——工厂（Factory）模式的改进 (9) 重构第四步－IoC容器 (10) 控制反转（IoC）/依赖注入（DI） (10) 什么是控制反转/依赖注入？ (10) 依赖注入的三种实现形式 (11) BeanFactory (13) BeanFactory管理Bean（组件）的生命周期 (14) Bean的定义 (15) Bean的之前初始化 (19) Bean的准备就绪（Ready）状态 (21) Bean的销毁 (21) ApplicationContext (21) Spring的AOP框架 (21) Spring的数据层访问 (21) Spring的声明式事务 (21) Spring对其它企业应用支持 (22)
名词解释 容器： 框架： 框架 容器 组件： 服务： Spring框架概述 主要内容：介绍Spring的历史，Spring的概论和它的体系结构，重点阐述它在J2EE中扮演的角色。 目的：让学员全面的了解Spring框架，知道Spring框架所提供的功能，并能将Spring 框架和其它框架（WebWork/Struts、hibernate）区分开来。 Spring是什么？ 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）和事务（）管理）进行内聚性的开发。应用对象只实
spring框架
由于软件开发的复杂性而创建了Spring框架。Spring使用基本的JavaBeans完成以前只能由EJB完成的事情。但是，Spring的使用不仅限于服务器端开发。从简单性，可测试性和松散耦合的角度来看，大多数Java应用程序都可以从Spring中受益。 ◆目的：解决企业应用开发的复杂性 ◆功能：使用基本的JavaBean代替EJB，并提供更多的企业应用程序功能 ◆范围：任何Java应用程序 Spring是控制（IoC）和面向方面（AOP）容器框架的轻量级反转。要谈Spring的历史，就要先谈J2EE。J2EE应用程序的广泛实现是在1999年和2000年开始的，它的出现带来了诸如事务管理之类的核心中间层概念的标准化，但是在实践中并没有获得绝对的成功，因为开发效率，开发难度和实际的性能都令人失望。 曾经使用过EJB开发JAVA EE应用的人，一定知道，在EJB开始的学习和应用非常的艰苦，很多东西都不能一下子就很容易的理解。EJB 要严格地实现各种不同类型的接口，类似的或者重复的代码大量存在。而配置也是复杂和单调，同样使用JNDI进行对象查找的代码也是单调而枯燥。虽然有一些开发工作随着xdoclet的出现，而有所缓解，但是学习EJB的高昂代价，和极低的开发效率，极高的资源消耗，都造成了EJB的使用困难。而Spring出现的初衷就是为了解决类似的这些问题。 Spring的一个最大的目的就是使JAVA EE开发更加容易。同时，
Spring之所以与Struts、Hibernate等单层框架不同，是因为Spring 致力于提供一个以统一的、高效的方式构造整个应用，并且可以将单层框架以最佳的组合揉和在一起建立一个连贯的体系。可以说Spring是一个提供了更完善开发环境的一个框架，可以为POJO(Plain Ordinary Java Object)对象提供企业级的服务。Spring的形成，最初来自Rod Jahnson所著的一本很有影响力的书籍《Expert One-on-One J2EE Design and Development》，就是在这本书中第一次出现了Spring的一些核心思想，该书出版于2002年。另外一本书《Expert One-on-One J2EE Development without EJB》，更进一步阐述了在不使用EJB开发JAVA EE企业级应用的一些设计思想和具体的做法。有时间了可以详细的研读一下。Spring的初衷: 1、JAVA EE开发应该更加简单。 2、使用接口而不是使用类，是更好的编程习惯。Spring将使用接口的复杂度几乎降低到了零。 3、为JavaBean提供了一个更好的应用配置框架。 4、更多地强调面向对象的设计，而不是现行的技术如JAVA EE。 5、尽量减少不必要的异常捕捉。 6、使应用程序更加容易测试。 Spring的目标: 1、可以令人方便愉快的使用Spring。 2、应用程序代码并不依赖于Spring APIs。
简介Java的Spring框架的体系结构以及安装配置
体系结构 Spring有可能成为所有企业应用程序的一站式服务，然而，Spring是模块化的，使您可以挑选哪些模块是适用的，而不必把在余下的也引入。以下部分给出详细介绍在Spring框架中所有可用的模块。 Spring框架提供约20个模块，可以根据应用程序的要求来使用。 网店转让
响应式网站制作 p2p网站制作 a货包包
游戏制作学习 核心容器： 核心容器组成的核心，Beans，上下文和表达式语言模块，其细节如下： 核心模块提供了框架的基本组成部分，包括IoC和依赖注入功能。 Bean模块提供BeanFactory是工厂模式的经典实现。 Context 上下文模块建立在由核心和Bean类模块提供了坚实的基础，它是访问定义和配置的任何对象的媒介。在ApplicationContext接口是上下文模块的焦点。. 表达式语言模块提供了在运行时查询和操作对象图的强大的表达式语言。 数据访问/集成： 数据访问/集成层包括JDBC，ORM，OXM，JMS和事务处理模块，其细节如下： JDBC模块提供了不再需要冗长的JDBC编码相关了JDBC的抽象层。 ORM模块提供的集成层。流行的对象关系映射API，包括JPA，JDO，Hibernate和iBatis。OXM模块提供了一个支持对象/ XML映射实现对JAXB，Castor，使用XMLBeans，JiBX和XStream的抽象层。 Java消息服务JMS模块包含的功能为生产和消费的信息。 事务模块支持编程和声明式事务管理实现特殊接口类，并为所有的POJO。 Web: 在Web层包括网络，Web-Servlet，Web-Struts和网络的Portlet组件，其细节如下：Web模块提供了基本的Web开发的集成特性，例如多方文件上传功能和使用的servlet监听器的IoC容器初始化和针对Web的应用程序上下文。 Web-Servlet 模块包含Spring的模型- 视图- 控制器（MVC）实现Web应用程序。Web-Struts 模块包含支持类内的Spring应用程序集成了经典的Struts Web层。 Web-Portlet模块提供了MVC实现在portlet环境中使用和镜子Web的Servlet的模块的功能。
Spring框架研究与应用
学校代号10536 学号0810802539 分类号TP18 密级公开 硕士学位论文 Spring框架研究与应用 学位申请人姓名肖露 培养单位长沙理工大学 导师姓名及职称龙鹏飞教授 学科专业计算机软件与理论 研究方向软件工程 论文提交日期2011年5月
学校代号：10536 学号：0810802539 密级：公开 长沙理工大学硕士学位论文 Spring框架研究与应用 学位申请人姓名肖露 导师姓名及职称龙鹏飞教授 培养单位长沙理工大学 专业名称计算机软件与理论 论文提交日期2011年4月 论文答辩日期2011年5月 答辩委员会主席车生兵教授
Spring Framework Research and Application by Xiao Lu B.E.( HaiNan University) 2008 A thesis submitted in partial satisfaction of the Requirements for the degree of Master of Engineering in Computer Software and Theory in Changsha University of Science & Technology Supervisor Professor Long Pengfei March, 2011
长沙理工大学 学位论文原创性声明 本人郑重声明：所呈交的论文是本人在导师的指导下独立进行研究所取得的研究成果。除了文中特别加以标注引用的内容外，本论文不包含任何其他个人或集体已经发表或撰写的成果作品。对本文的研究做出重要贡献的个人和集体，均已在文中以明确方式标明。本人完全意识到本声明的法律后果由本人承担。 作者签名：日期：年月日 学位论文版权使用授权书 本学位论文作者完全了解学校有关保留、使用学位论文的规定，同意学校保留并向国家有关部门或机构送交论文的复印件和电子版，允许论文被查阅和借阅。本人授权长沙理工大学可以将本学位论文的全部或部分内容编入有关数据库进行检索，可以采用影印、缩印或扫描等复制手段保存和汇编本学位论文。 本学位论文属于 1、保密□，在______年解密后适用本授权书。 2 （请在以上相应方框内打“√”） 作者签名：日期：年月日 导师签名：日期：年月日
spring框架
spring框架 Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。 ◆目的:解决企业应用开发的复杂性 ◆功能:使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 ◆范围:任何Java应用 Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。 Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 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文件
Struts+Hibernate+Spring+三个框架简介
Struts 是一个为开发基于模型(Model)－视图(View)－控制器(Controller)(MVC)模式的应用架构的开源框架，是利用Java Servlet和JSP构建Web应用的一项非常有用的技术。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，因而吸引了众多的开发人员的关注。 首先事件是指从客户端页面（浏览器）由用户操作触发的事件，Struts使用Action来接受浏览器表单提交的事件，这里使用了Command 模式，每个继承Action的子类都必须实现一个方法execute。 struts重要的表单对象ActionForm是一种对象，它代表了一种应用，这个对象中至少包含几个字段，这些字段是Jsp页面表单中的input字段，因为一个表单对应一个事件，所以，当我们需要将事件粒度细化到表单中这些字段时，也就是说，一个字段对应一个事件时，单纯使用Struts就不太可能，当然通过结合JavaScript也是可以转弯实现的。 Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。 Struts框架可分为以下四个主要部分： 1、模型(Model)，本质上来说在Struts中Model是一个Action类(这个会在后面详细讨论)，开发者通过其实现商业逻辑，同时用户请求通过控制器(Controller)向Action的转发过程是基于由struts- config.xml文件描述的配置信息的。 2、视图(View)，View是由与控制器Servlet配合工作的一整套JSP定制标签库构成，利用她们我们可以快速建立应用系统的界面。 3、控制器(Controller)，本质上是一个Servlet，将客户端请求转发到相应的Action类。
请介绍一下Spring框架中Bean的生命周期
请介绍一下Spring框架中Bean的生命周 期 这个配置文件就定义了一个标识为HelloWorld 的Bean。在一个配置文档中可以定义多个Bean。二、Bean的初始化有两种方式初始化Bean。1、在配置文档中通过指定init-method 属性来完成在Bean的类中实现一个初始化Bean属性的方法，如init()，如：public class HelloWorld{public String msg=null;public Date date=null;public void init() {msg=”HelloWorld”;date=new Date();}……}然后，在配置文件中设置init-mothod属性：2、实现org.springframwork.beans.factory.InitializingBean接口Bean实现InitializingBean接口，并且增加afterPropertiesSet() 方法：public class HelloWorld implement InitializingBean {public String msg=null;public Date date=null;public void afterPropertiesSet() {msg=”向全世界问好！”;date=new Date();}……}那么，当这个Bean的所有属性被Spring的BeanFactory设置完后，会自动调用afterPropertiesSet()方法对Bean进行初始化，于是，配置文件就不用指定init-method属性了。 三、Bean的调用有三种方式可以得到Bean并进行调用：1、使用BeanWrapperHelloWorld hw=new HelloWorld();BeanWrapper bw=new BeanWrapperImpl(hw);bw.setPropertyvalue(“msg”,”
Spring框架有哪几部分组成-
Spring框架有哪几部分组成? 问题：Spring框架有哪几部分组成? 回答： Spring框架有七个模块组成组成，这7个模块(或组件)均可以单独存在，也可以与其它一个或多个模块联合使用，主要功能表现如下： Spring 核心容器（Core）：提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，她是工厂模式的实现。BeanFactory使用控制反转（Ioc）模式将应用程序的配置和依赖性规范与实际的应用代码程序分开。 Spring AOP：通过配置管理特性，Spring AOP模块直接面向方面的编程功能集成到了Spring框架中，所以可以很容易的使Spring框架管理的任何对象支持AOP。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖于EJB组件，就可以将声明性事务管理集成到应用程序中。 Spring ORM：Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括JDO、Hibernate、iBatis和TopLink。所有这些都遵从Spring的通用事务和DAO异常层结构。 Spring DAO：JDBC DAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应商抛出的异常错误
信息。异常层次结构简化了错误处理，并且大大的降低了需要编写的异常代码数量（例如，打开和关系连接）。Spring DAO的面向JDBC 的异常遵从通用的DAO异常层结构。 Spring WEB：Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用程序提供了上下文的服务。所以Spring框架支持Jakarta Struts的集成。Web模块还简化了处理多部分请求及将请求参数绑定到域对象的工作。 Spring上下文（Context）：Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化校验和调度功能。 Spring MVC：Spring的MVC框架是一个全功能的构建Web 应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText 和Pol
各种框架架构图简介
1.Spring 架构图 Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为J2EE 应用程序开发提供集成的框架。Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定J2EE 服务的可重用业务和数据访问对象。这样的对象可以在不同J2EE 环境（Web或EJB ）、独立应用程序、测试环境之间重用。 组成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 异常层次结构。 2.ibatis 架构图 ibatis 是一个基于Java的持久层框架。 iBATIS 提供的持久层框架包括SQL Maps 和Data Access Objects （ DAO ），同时还提供一个利用这个框架开发的 JPetStore 实例。 IBATIS ：最大的优点是可以有效的控制sql 发送的数目，提高数据层的执行效率！它需要程序员自己去写sql 语句，不象hibernate 那样是完全面向对象的，自动化的，ibatis 是半自动化的，通过表和对象的映射以及手工书写的sql 语句，能够实现比hibernate 等更高的查询效率。 Ibatis 只是封装了数据访问层，替我们做了部分的对象关系映射。但代价是必须要写xml配置文件，相对于Hibernate 还要写很多sql 。Hibernate 通过工具直接从数据库模式生成实体类和基本的配置文件，而且大部分情况下不需要我们写sql ，会较大的提升开发效率。但这些也有很多的局限性，尤其是对