spring包详解

合集下载

Spring简介

Spring简介什么是Spring?spring是分层的avaSE以及javaEE应⽤于全栈的轻量级开源框架，以IOC（Inverse Of Control）控制反转,AOP(Aspect Oriented Programing)⾯向切⾯编程为核⼼，提供表现层SpringMVC以及持久层Spring,并且可整合多种其他开源框架。

spring的本质是管理对象，包括创建对象及维护对象之间的关系。

spring的优点1)⽅便解耦，简化开发通过spring的IOC可将对象的创建，以及对象之间的依赖都交由spring容器来进⾏管理，这样可以降低程序之间的耦合。

并且开发时也只需关注上层的应⽤，不⽤再多关注底层的应⽤。

2）AOP编程的⽀持spring⽀持AOP⾯向切⾯编程，许多OOP⾯向对象编程不能或很难实现的功能，都可通过AOP轻松实现。

3）声明式事务的⽀持可以将我们从单调烦闷的事务管理中解放出来，通过声明式事务的⽅式，可以灵活的进⾏事务管理，进⽽提⾼开发的质量和效率。

4）⽅便程序的测试可以⽤⾮容器依赖的编程⽅式进⾏⼏乎所有的测试⼯作，测试不再是昂贵的操作，⽽是随⼿可做的事情。

5）⽅便集成各种优秀的框架Spring可以降低各种框架的使⽤难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接⽀持。

6）降低javaEE的API的使⽤难度Spring对 JavaEE API（如 JDBC、JavaMail、远程调⽤等）进⾏了薄薄的封装层，使这些API 的使⽤难度⼤为降低。

7)spring框架的源码是经典学习的案例Spring的源代码设计精妙、结构清晰、匠⼼独⽤，处处体现着⼤师对Java设计模式灵活运⽤以及对 Java技术的⾼深造诣。

它的源代码⽆疑是Java技术的最佳实践的范例。

通过Spring进⾏解耦什么叫程序的耦合？在程序中，对象之间相互依赖，相互传递数据，这种相互关联的程度越⾼，程序的耦合度就越⾼。

Spring核心技术详解

Spring核⼼技术详解⼀、Sring简介Spring是⼀个分层的Java SE/EE应⽤⼀站式的轻量级开源框架。

Spring核⼼是IOC和AOP。

Spring主要优点包括：⽅便解耦，简化开发，通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进⾏控制，避免硬编码造成的程序耦合度⾼。

AOP编程的⽀持，通过Spring提供的AOP功能，⽅便进⾏⾯向切⾯编程。

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

⽅便程序的测试，可以⽤⾮容器依赖的编程⽅式进⾏⼏乎所有的测试⼯作。

⽅便集成各种优秀框架，Spring提供了对各种优秀框架的直接⽀持。

⼆、Spring体系结构如下图所⽰，整个spring框架按其所属功能可以划分为五个主要模块，这五个模块⼏乎为企业应⽤提供了所需的⼀切，从持久层、业务层到表现层都拥有相应的⽀持，这就是为什么称Spring是⼀站式框架的原因。

核⼼模块(Core Container) Spring的核⼼模块实现了IoC的功能，它将类和类之间的依赖从代码中脱离出来，⽤配置的⽅式进⾏依赖关系描述。

由IoC容器负责类的创建，管理，获取等。

BeanFactory接⼝是Spring框架的核⼼接⼝，实现了容器很多核⼼的功能。

Context模块构建于核⼼模块之上，扩展了BeanFactory的功能，包括国际化，资源加载，邮件服务，任务调度等多项功能。

ApplicationContext是Context模块的核⼼接⼝。

表达式语⾔(Expression Language)是统⼀表达式语⾔(EL)的⼀个扩展，⽀持设置和获取对象属性，调⽤对象⽅法，操作数组、集合等。

使⽤它可以很⽅便的通过表达式和Spring IoC容器进⾏交互。

AOP模块Spring AOP模块提供了满⾜AOP Alliance规范的实现，还整合了AspectJ这种AOP语⾔级的框架。

Spring总结————spring核心Core

Spring总结————spring核⼼Core⼀、spring的概念spring是⼀个开源的，轻量级控制反转和⾯向切⾯的容器框架，解决企业应⽤开发的复杂性，降低耦合，更易于测试。

spring春天。

如果写⼀个⼩的项⽬，我们可以在项⽬中想创建⼀个对象就创建i个对象，但对于⼤型项⽬来说，可能需要依赖⼏百个类，类与类关系也⾮常复杂，我们就不能把创建对象和维护对象之间的关系放到项⽬中，可以采⽤⽣活中分⼯合作的⽅式，把对象的创建和维护关系给剥离出来，找⼀个⼯⼚类的东西去⼲这些事，这样项⽬如果需要对象了，就从⼯⼚类中去取。

spring就是为了让我们以后能够做⼤的项⽬准备的。

spring核⼼的功能就是⼀个⼯⼚模式，spring相当于为你的项⽬专门成⽴⼀个⼯⼚，这个⼯⼚负责创建对象，委会对象之间的关系，以前是直接new，现在从spring的⼯⼚⾥⾯获取。

⼆、spring的bean的常⽤属性scopescope⽤来配置bean对象是否是单例测试。

单例模式是java的23种设计模式之⼀，指在这个项⽬运⾏过程中⼀个类的对象只会实例化⼀次。

⼀般，⼯⼚类的对象都是单例模式。

⾮单例模式叫多例模式或者原型模式。

spring⼯⼚中的对象默认都是单例模式，如果我们想把对象配置成多例模式，可以配置bean的scope属性，scope常⽤的两个取值：singleon默认值单例模式prototype 原型模式多例模式单例模式下，对象是在⼯⼚初始化的时候创建的。

多例模式是在⼯⼚初始化之后，获取对象的时候创建的。

autowireautowire⽤来配置spring对象属性的默认的装配⽅式。

有三个取值no：默认值不启⽤⾃动装配byType：根据类型⾃动装配byName：根据名称⾃动装配，⼀般bean的name如果不声明默认值取的就是id三、spring的bean的属性注⼊的两种⽅式设值注⼊设值注⼊要求：要求属性在实体类中必须有getter和setter⽅法，然后在spring的⼯⼚中就可以使⽤property标签进⾏设值注⼊。

SpringBoot之SpringBootStarter依赖包及作用

SpringBoot之SpringBootStarter依赖包及作用Spring Boot Starter 是 Spring Boot 提供的一系列依赖包，用于简化 Spring Boot 项目的配置和开发过程。

它们是预定义的一组 Maven依赖，可以根据不同的需求和场景进行引入。

下面是一些常用的 Spring Boot Starter 依赖包及其作用。

1. spring-boot-starter-web：用于构建 Web 应用程序的基本依赖，包括 Spring MVC、Tomcat 和 Jackson等。

2. spring-boot-starter-data-jpa：用于支持使用 JPA（Java Persistence API）进行数据库访问的依赖，包括 Hibernate 和 Spring Data JPA等。

3. spring-boot-starter-thymeleaf：用于支持使用 Thymeleaf 进行前端页面渲染的依赖。

4. spring-boot-starter-security：用于实现身份认证和授权功能的依赖，包括 Spring Security 和 Spring Session等。

5. spring-boot-starter-actuator：用于监控和管理 Spring Boot应用程序的依赖，包括健康检查、指标收集和管理端点等。

6. spring-boot-starter-test：用于支持编写单元测试和集成测试的依赖，包括 JUnit、Mockito 和 Hamcrest等。

7. spring-boot-starter-logging：用于支持日志记录和管理的依赖，包括 Logback 和 Log4j2等。

8. spring-boot-starter-cache：用于支持缓存功能的依赖，包括Ehcache 和 Caffeine等。

9. spring-boot-starter-data-mongodb：用于支持使用 MongoDB 进行数据库访问的依赖，包括 Spring Data MongoDB等。

Spring源码分析基本介绍

Spring源码分析基本介绍摘要：本⽂结合《Spring源码深度解析》来分析Spring 5.0.6版本的源代码。

若有描述错误之处，欢迎指正。

前⾔作为⼀名开发⼈员，阅读源码是⼀个很好的学习⽅式。

本⽂将结合《Spring源码深度解析》来分析Spring 5.0.6版本的源代码，若有描述错误之处，欢迎指正。

Spring是2003年兴起的⼀个轻量级Java开源框架，旨在解决企业应⽤开发的复杂性。

Spring发展⾄今，衍⽣出⾮常丰富的模块，并应⽤在多种场景，⽐如：桌⾯应⽤，Web应⽤等。

Spring的模块化可以允许你只使⽤需要的模块，⽽不必全部引⼊。

⽬录⼀、整体架构1. 核⼼容器2. 数据访问/集成3. Web4. AOP5. Test⼆、设计理念三、使⽤场景1. 典型的Spring web应⽤程序2. Spring中间层使⽤第三⽅web框架3. 远程调⽤4. EJBs-包装现存POJOs⼀、整体架构Spring框架是⼀个分层架构，他包含⼀系列的功能要素，并被分为⼤约20个模块，如下图所⽰（很遗憾，并没有找到Spring5的架构图，下图是Spring4的，但结合Spring5的源码来看，该图还是能够体现Spring5的核⼼模块）这些模块被总结为以下⼏部分。

1. 核⼼容器Core Container（核⼼容器）包含有Core、Beans、Context和Expression Language模块。

Core和Beans模块是框架的基础部分，提供IoC（控制反转）和DI（依赖注⼊）特性。

这⾥的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。

Core模块主要包含Spring框架基本的核⼼⼯具类，Spring的其他组件都要使⽤到这个包⾥的类，Core模块是其他组件的基本核⼼。

当然你也可以在⾃⼰的应⽤系统中使⽤这些⼯具类。

Spring常用的一些注解说明

Spring常⽤的⼀些注解说明@Configuration从Spring3.0，@Configuration⽤于定义配置类，可替换xml配置⽂件，被注解的类内部包含有⼀个或多个被@Bean注解的⽅法。

这些⽅法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进⾏扫描，并⽤于构建bean定义。

@Bean@Bean注解⽤于告诉⽅法，产⽣⼀个Bean对象，然后这个Bean对象交给Spring管理。

产⽣这个Bean对象的⽅法Spring只会调⽤⼀次，随后这个Spring将会将这个Bean对象放在⾃⼰的IOC容器中。

SpringIOC 容器管理⼀个或者多个bean，这些bean都需要在@Configuration注解下进⾏创建，在⼀个⽅法上使⽤@Bean注解就表明这个⽅法需要交给Spring进⾏管理。

@Autowired、@Resource@Resource和@Autowired注解都是⽤来实现依赖注⼊的。

只是@AutoWried按by type⾃动注⼊，⽽@Resource默认按byName⾃动注⼊。

♣ @Autowired@Autowired具有强契约特征，其所标注的属性或参数必须是可装配的。

如果没有Bean可以装配到@Autowired所标注的属性或参数中，⾃动装配就会失败，抛出NoSuchBeanDefinitionException.@Autowired可以对类成员变量、⽅法及构造函数进⾏标注，让 spring 完成 bean ⾃动装配的⼯作。

@Autowired 默认是按照类去匹配，配合 @Qualifier 指定按照名称去装配 bean。

♣ @Resource@Resource是JDK提供的注解，有两个重要属性，分别是name和type。

@Resource依赖注⼊时查找bean的规则既不指定name属性，也不指定type属性，则⾃动按byName⽅式进⾏查找。

spring原理和实现机制

spring原理和实现机制Spring框架是一个开源的应用程序框架，它提供了一种简单的方法来构建基于Java的企业级应用程序。

Spring框架的原理和实现机制主要包括：1. 控制反转（IoC）：Spring使用控制反转（Inversion of Control，IoC）来管理应用程序中的对象。

传统的应用程序中，对象的创建和依赖关系管理是由程序员来实现的，而在Spring 中，对象的创建和管理工作由容器来完成。

容器会在应用程序启动时创建对象，并通过依赖注入的方式将对象之间的依赖关系注入到相应的对象中。

2. 依赖注入（DI）：依赖注入是Spring框架的核心机制之一。

它指的是容器在创建对象时，自动将其所依赖的其他对象注入进来。

通过依赖注入，对象之间的解耦程度大大提高，使得应用程序更加灵活、可扩展和可维护。

3. 面向切面编程（AOP）：Spring框架通过面向切面编程（Aspect-Oriented Programming，AOP）来实现横切关注点的模块化。

AOP可以将应用程序的核心逻辑（称为核心关注点）与横切关注点（如日志、事务管理等）分离开来，并通过切面来统一管理这些横切关注点。

4. 核心容器：Spring框架的核心是其容器（Container）。

容器使用BeanFactory接口作为底层容器的基础，并提供了ApplicationContext接口作为更高级的容器接口。

容器负责创建和管理应用程序中的对象，并提供了丰富的配置和管理功能。

5. 层次化的模块化架构：Spring的模块化架构使得开发者可以根据自己的需要选择使用不同的模块。

例如，Spring的核心模块包括IoC容器、AOP框架和BeanFactory等，而其他模块如Spring MVC、Spring Data等则提供了特定领域的解决方案。

6. 轻量级与非侵入性：Spring框架的设计理念是轻量级和非侵入性的。

它不依赖于特定的编程模型，可以与其他技术和框架无缝集成。

spring jar 包详解

下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。

aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。

Aspectj是java 最早的提供AOP的应用框架。

dist 目录下是 Spring 的发布包，关于发布包下面会详细进行说明。

docs 目录下是相关的文档，包括有Spring api 的javadoc、reference 参考指南、Spring 的标签库使用文件及Spring MVC 的MVC-step-by-step 讲解与示例。

都是很好的文档，值得好好研究一下。

lib 目录下是Spring 所依赖的第三方开源包。

mock 目录下是 Spring 辅助应用测试的Mock 源程序。

samples 目录下是 Spring 的示例源程序及简单的webapp 示例框架的示例配置，值得好好学习的有jpetstore 及petclinic，当然其它的countries、imagedb、tiles-example 也可以好好参考一下。

src 目录下是Spring 的源程序。

test 目录下Spring 的单元测试源程序。

tiger 目录下是针对在Spring框架中使用java 1.5的源程序及测试程序。

Tiger是jdk 1.5版本的开发代号。

接下来详细说说dist 目录下jar 包的相关内容。

了解这些内容有助于我们减小发布包的大小，同时也可以增加对Spring架构的了解。

spring.jar 是包含有完整发布模块的单个jar 包。

但是不包括mock.jar, aspects.jar, spring-portlet.jar, and spring-hibernate2.jar。

spring-src.zip就是所有的源代码压缩包。

除了spring.jar 文件，Spring 还包括有其它21 个独立的jar 包，各自包含着对应的Spring 组件，用户可以根据自己的需要来选择组合自己的jar 包，而不必引入整个spring.jar 的所有类文件。

Spring_c3p0 配置详解

<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
配置一个数据源
Spring在第三方依赖包中包含了两个数据源的实现类包，其一是Apache的DBCP，其二是 C3P0。可以在Spring配置文件中利用这两者中任何一个配置数据源。
DBCP数据源
DBCP类包位于 /lib/jakarta-commons/commons-dbcp.jar，DBCP是一个依赖 Jakarta commons-pool对象池机制的数据库连接池，所以在类路径下还必须包括/lib/jakarta- commons/commons-pool.jar。下面是使用DBCP配置MySql数据源的配置片断：
<property name="maxIdleTime">
<value>60</value>
</property>

<property name="acquireIncrement">
<value>root</value>
</property>
<property name="password">

Spring核心注解

Spring注解使⽤场景启始版本模式注解@Repository数据仓储模式注解Spring Framework 2.0 @Component通⽤组件模式注解Spring Framework 2.5 @Service服务模式注解Spring Framework 2.5 @Controller Web控制器模式注解Spring Framework 2.5 @Configuration配置类模式注解Spring Framework 3.0装配注解@ImportResource替换XML元素<import>Spring Framework 2.5 @Import限定@Autowired依赖注⼊范围(导⼊对应的 @Configuration 标识类)Spring Framework 3.0 @ComponentScan扫描制定package下标注Spring模式注解的类Spring Framework 3.1依赖注⼊注解@Autowired Bean依赖注⼊，⽀持多种依赖查找⽅式Spring Framework 2.5 @Qualifier细粒度的@Autowired依赖查找⽅式Spring Framework 2.5 @Resource [JAVA注解]Bean依赖注⼊，仅⽀持名称依赖查找⽅式Spring Framework 2.5 Bean定义注解@Bean替换XML元素<bean/>Spring Framework 3.0 @DependsOn替换XML属性<bean depends-on="..."/>Spring Framework 3.0 @Lazy替代XML属性<bean lazy-init="true|false"/>Spring Framework 3.0 @Primary替换XML属性<bean primary="true|false"/>Spring Framework 3.0 @Role替换XML属性<bean role="..."/>Spring Framework 3.1 @Lookup替代XML属性<bean lookup-method="..."/>Spring Framework 4.1条件装配注解@Profile配置化条件装配Spring Framework 3.1 @Conditional编程条件装配Spring Framework 4.0配置属性注解@PropertySource配置属性抽象PropertySource注解Spring Framework 3.1 @PropertySources@PropertySource集合注解(实现 JAVA 8 @Repeatable相似的功能)Spring Framework 4.0⽣命周期回调注解@PostConstruct替换XML元素<bean init-method="..."/>或InitializingBean Spring Framework 2.5 @PreDestory替换XML元素<bean destory-method="..."/>或 DisposableBean Spring Framework 2.5注解属性注解@AliasFor别名注解属性，实现复⽤的⽬的Spring Framework 4.2性能注解@Indexed提升Spring模式注解的扫描效率(编译时会在classPath下⽣成 META-INF/ponents⽂件)Spring Framework 5.0Spring核⼼注解Spring核⼼注解归类如下：。

spring内核详解

Spring作为现在最优秀的框架之一，已被广泛的使用，51CTO也曾经针对Spring框架中的JDBC应用做过报道。

本文将从另外一个视角试图剖析出Spring框架的作者设计Spring框架的骨骼架构的设计理念，有那几个核心组件？为什么需要这些组件？它们又是如何结合在一起构成Spring的骨骼架构？Spring的AOP特性又是如何利用这些基础的骨骼架构来工作的？Spring中又使用了那些设计模式来完成它的这种设计的？它的这种设计理念对对我们以后的软件设计有何启示？本文将详细解答这些问题。

Spring的骨骼架构Spring总共有十几个组件，但是真正核心的组件只有几个，下面是Spring框架的总体架构图：图1.Spring框架的总体架构图从上图中可以看出Spring框架中的核心组件只有三个：Core、Context和Beans。

它们构建起了整个Spring 的骨骼架构。

没有它们就不可能有AOP、Web等上层的特性功能。

下面也将主要从这三个组件入手分析Spring。

Spring的设计理念前面介绍了Spring的三个核心组件，如果再在它们三个中选出核心的话，那就非Beans组件莫属了，为何这样说，其实Spring就是面向Bean的编程（BOP,Bean Oriented Programming），Bean在Spring 中才是真正的主角。

Bean在Spring中作用就像Object对OOP的意义一样，没有对象的概念就像没有面向对象编程，Spring中没有Bean也就没有Spring存在的意义。

就像一次演出舞台都准备好了但是却没有演员一样。

为什么要Bean这种角色Bean或者为何在Spring如此重要，这由Spring框架的设计目标决定，Spring为何如此流行，我们用Spring 的原因是什么，想想你会发现原来Spring解决了一个非常关键的问题他可以让你把对象之间的依赖关系转而用配置文件来管理，也就是他的依赖注入机制。

spring成神之路第三篇：Spring容器基本使用及原理（ApplicationCont。。。

spring成神之路第三篇：Spring容器基本使⽤及原理（ApplicationCont。

1. jdk1.82. idea3. maven-3.6.14. spring-5.2.3.RELEASEIOC容器是具有依赖注⼊功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个⽣命周期都是由容器来控制。

我们需要使⽤的对象都由ioc容器进⾏管理，不需要我们再去⼿动通过new的⽅式去创建对象，由ioc 容器直接帮我们组装好，当我们需要使⽤的时候直接从ioc容器中直接获取就可以了。

那么spring ioc容器是如何知道需要管理哪些对象呢？需要我们给ioc容器提供⼀个配置清单，这个配置⽀持xml格式和java注解的⽅式，在配置⽂件中列出需要让ioc容器管理的对象，以及可以指定让ioc容器如何构建这些对象，当spring容器启动的时候，就会去加载这个配置⽂件，然后将这些对象给组装好以供外部访问者使⽤。

这⾥所说的IOC容器也叫spring容器。

由spring容器管理的对象统称为Bean对象。

Bean就是普通的java对象，和我们⾃⼰new的对象其实是⼀样的，只是这些对象是由spring去创建和管理的，我们需要在配置⽂件中告诉spring容器需要创建哪些bean对象，所以需要先在配置⽂件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象。

1. 引⼊spring相关的maven配置2. 创建bean配置⽂件，⽐如bean xml配置⽂件3. 在bean xml⽂件中定义好需要spring容器管理的bean对象4. 创建spring容器，并给容器指定需要装载的bean配置⽂件，当spring容器启动之后，会加载这些配置⽂件，然后创建好配置⽂件中定义好的bean对象，将这些对象放在容器中以供使⽤5. 通过容器提供的⽅法获取容器中的对象，然后使⽤spring内部提供了很多表⽰spring容器的接⼝和对象，我们来看看⽐较常见的⼏个容器接⼝和具体的实现类。

spring配置详解

spring配置详解1.前⾔公司⽼项⽬的后台，均是基于spring框架搭建，其中还⽤到了log4j.jar等开源架包。

在新项⽬中，则是spring和hibernate框架均有使⽤，利⽤了hibernate框架，来实现持久化，简化sql操作等。

Hibernate配置⽂件可以有两种格式，⼀种是 hibernate.properties，另⼀种是hibernate.cfg.xml。

后者稍微⽅便⼀些，当增加hbm映射⽂件的时候，可以直接在 hibernate.cfg.xml ⾥⾯增加，不必像 hibernate.properties 必须在初始化代码中加⼊。

我们新项⽬中使⽤的是hibernate.cfg.xml格式。

不过在本⽂中不将细述，后续有机会再补上。

公司项⽬中，中间件主要有tomcat，webshpere，WebLogic。

以下，将对项⽬中spring基本配置，log4j的配置，还有中间件的相关参数配置做⼀个初步的介绍。

2.spring配置——以⽼GIS项⽬为例⼦GISV13中的配置涉及到了SpringMVC,IOC,AOP, Quartz⽅⾯的配置。

配置的实现是通过注记配置和XML配置来合作实现。

这⾥，我将按照Spring的配置流程，将其他⼏个⽅⾯的配置融合其中，来进⾏全⾯解析。

2.1SpringMVC的配置2.1.1.web.xml的配置Web程序中，当中间件启动时，中间件会⾸先读取web.xml中的配置。

在web.xml中可以配置监听器，过滤器，servlet映射等等。

在Spring 框架中，我们主要需配置容器初始化时读取的spring容器配置⽂件的路径以及springMVC中的分发器DispatcherServlet。

在GISV13的web.xml中，我们定义了如下内容：InitGISConfigServlet定义了容器启动时，⾸先要运⾏这个⽅法。

然后servletname为MVC的这部分便是定义了springMVC的分发器以及此servlet所对应的加载配置⽂件的路径。

Spring总结

Spring总结Spring总结1、spring两⼤核⼼接⼝的区别2.spring读取配置⽂件1.BeanFactoryi从src下查找配置⽂件：Resource res = new ClassPathResource("applicationContext.xml")ii.从⽂件系统中读取配置⽂件：Resource res = new FileSystemResource("applicationContext.xml")iii.web环境中读取配置⽂件Resource res = new ServletContextResource("applicationContext.xml")2.ApplicationContextApplicationContext context = null;i从src下查找配置⽂件：context = new ClassPathXmlApplicationContext ("applicationContext.xml") ii.从⽂件系统中读取配置⽂件：context = new FileSystemXmlApplicationContext ("applicationContext.xml") iii.web环境中读取配置⽂件context = new XmlWebApplicationContext ("applicationContext.xml")3.Spring :组合对象和对象之间的关系，也可以组合框架和框架之间的关系4.Spring是轻量级的ioc和aop的容器框架1)轻量级：使⽤时程序所占⽤的资源很少，⾮侵⼊性（松耦合）2)IoC(Inversion Of Control):控制反转,对象和如何得到它的协作对象的责任反转3)AOP：⾯向切⾯的编程4)容器：控制容器内对象的⽣命周期5)框架：⼀些对象通过构建提供共通性的功能，可以简化程序的开发5.Spring第⼀个项⽬1)创建java项⽬，引⼊核⼼jar包(Spring.jar)2）引⼊配置⽂件(打印⽇志log4j:log4j.properties)Spring : applicationContext.xml3)增加测试类4）BeanFactory 是核⼼接⼝，可以获取配置⽂件中声明的对象，组合对象之间的关系，可以维护对象的⽣命周期5)spring创建对象默认是单例创建的6)使⽤ApplicationContext 代替BeanFactory （推荐使⽤），可以从框架级别上提供更多的⽀持6.不通过编码⽅式设置属性1.可以在property标签中声明属性2.DI(DenpendencyInjection)依赖注⼊的三种⽅式1)接⼝注⼊(不推荐使⽤)2)set⽅法(属性)注⼊（要先有对象）3)构造⽅法注⼊3.细讲set⽅法的属性注⼊1.属性注⼊必须有set⽅法2.⼀个对象中有另⼀个对象的引⽤的情况，在配置时采⽤ref来参照另⼀个对象，ref要和另⼀个对象的id相同3.属性是数组，list集合的场合：在属性⾥⾯使⽤list标签，如果是list集合（使⽤泛型），获得的是ArrayList类型，如果集合不使⽤泛型，可以放任何类型的数据;4.属性是map集合，使⽤map标签，获得的是LinkedHashMap类型的5.属性是set集合，使⽤set标签，获得的是LinkHashSet类型的hashSet重复不放，hashMap重复覆盖6.属性是Property集合,使⽤prop标签4.继承属性注⼊将⽗类的属性注⼊关系体现在⼦类中5.构造⽅法的注⼊1.在构造⽅法类型相同的情况下，标签的声明顺序和构造⽅法的参数顺序是完全相同的，如果不顺序不同，可增加index来区分2.在构造⽅法类型不同的情况下，多个构造⽅法不明确调⽤哪个时，可以增加参数的类型，参数的顺序没要求7.Spring属性编辑器(将字符串转换为⽇期类型)1.创建编辑器类，继承PropertyEditorSupport,重写setAsText ⽅法，注⼊属性时，⾃动调⽤，在⽅法中，最后⼀定要调⽤setV alue()放到对象的属性中2.属性编辑管理器(CustomEditorConfigurer)⾃动识别⾃定义的编辑器8.Spring的⾃动装配功能Autowire⾃动装配功能对java的简单类型不⽀持简单类型包括：基本类型，字符串类型，⽇期类型1.byName:如果⾃动装配采⽤ByName，那么使⽤时，会根据对象的属性名称在Spring环境中查找相同ID的Bean对象，如果查找到，那么直接赋值给响应的属性，如果找不到，不做任何处理byName不需要考虑特殊的情况2.byType:如果⾃动装配采⽤ByType，那么使⽤时，会根据对象的属性的类型在Spring环境中查找相同类型的Bean对象，如果查找到，那么直接赋值给响应的属性，如果找不到，不做任何处理使⽤时，需要注意，如果属性为引⽤类型时，Spring环境中如果存在多个类型相同的Bean对象，那么会发⽣错误如果属性为数组和集合时，Spring环境中如果存在多个类型相同的Bean对象，那么不会发⽣错误3.可以使⽤全局⾃动装配标签中使⽤Default-autowire="byName",只对当前⽂件有效9.Spring 的⽣命周期1.applicationContext在读取配置⽂件的时候就默认创建了对象，想在使⽤的时候再创建对象，⽤延迟加载(lazy-init = “true”),会出现这样的问题：使⽤了⾃动装配功能，那么延迟加载不起作⽤2如果创建对象后希望执⾏初始化⽅法，那么在延迟加载后声明init-method=”init”,初始化⽅法要求：⽅法⾥不能传参数，在设置属性之后执⾏，可以抛出异常3.调⽤销毁⽅法⽤destroy-method=””，很少⽤到4.对象默认是单例创建的，scope=”prototype”(原型创建)，声明这个属性之后，创建对象就是多例了，属性为scope=”singleton”,创建对象是单例的如果使⽤多例创建对象，设置延迟加载不起作⽤，肯定是在使⽤时创建5.依赖创建（depend-on）如果⼀个对象创建时，必须保证另外⼀个对象已经创建，那么使⽤依赖创建的⽅式10.Spring在web环境中的使⽤1.步骤：1.创建web环境2.增加jar包（Spring.jar）3.引⼊配置⽂件，放在src下4.修改Web.xml⽂件，增加对Spring的⽀持（增加监听器）2.在程序中就可以直接访问Spring对象了问题：如果修改了配置⽂件，必须重新启动服务器，否则不起作⽤，struts2有⾃动加载功能，注意区分3.Spring(将service对象组合到action对象中)+struts21.使⽤第⼀种⽅式，action由struts2创建，service由Spring创建2.引⼊相应的struts2配置3.引⼊额外的java包，Spring的插件：struts2-spring-plugin-2.1.8.1.jar使⽤插件jar包，不需要做其他⼯作，就可以将Action对象进⾏组合，因为底层，这个插件改变了获取Action对象及属性的创建⽅式。

Spring

Spring是一个轻量级的DI（IoC）和AOP容器框架。

存在的目的是用于构建轻量级的J2EE应用。

1.轻量级：应用大小和应用开支，包括应用方式2.DI（IoC)：提供松耦合的一种实现技术3.AOP：切面编程将业务逻辑从应用服务中分离4.容器：包含并管理应用对象的生命周期和配置5.框架：使用组件配置组合成复杂的应用，并提供很多基础功能项目中引入spring立即可以带来下面的好处1.降低组件之间的耦合度,实现软件各层之间的解耦。

2.可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。

当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。

3.容器提供单例模式支持，开发人员不再需要自己编写实现代码。

4.容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。

5.容器提供的众多辅作类，使用这些类能够加快应用的开发，如：JdbcT emplate、HibernateT emplate。

6.Spring对于主流的应用框架提供了集成支持，如：集成Hibernate、JPA、Struts等，这样更便于应用的开发。

第一个Spring应用(1):搭建环境,在spring最基础的应用中只需要dest\spring.jar和lib\jakarta-commons\commons-logging.jar新建spring的配置文件,文件名称可以任意,位置也可以任意,但考虑到通用性,一般将配置文件存放在类路径下,配置文件的模板可以在spring 参考手册中获取(查找中输入<bean>),模板大致如下：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd"></beans>(2):实例化spring容器,通过在类路径下寻找配置文件(配置文件可以有多个,以字符数组的形式传入)/* 当存在多个配置文件时,可以将spring配置文件名,字符串数组的形式传入 */ ApplicationContext ac = new ClassPathXmlApplicationContext("Spring-config.xml");(3):将实体bean的创建与维护交由spring管理在配置文件中的<beans>下使用<bean>标签<!—指定实体bean的名称,当名称含有特殊字符时,需要用name指定,一般情况下使用id,id 在配置文件中唯一,而name可以重复指定,获取时,获取到最后一个,在name中可以使用逗号将多个名称隔开,来达到指定bean的多个名称,当id和那么都没有指定时,则以类的全名作为name,如果存在多个name和id没有指定且实例类都是一样的bean,可以使用clazzpath/#来获取,#代表在xml中存在的序号--><!—calss指定需要被管理的实体bean,需要是完整的类名--><bean id="personService"class="com.mrkay.spring.services.impl.PersonServiceImpl"/> (4):调用实体bean使用实例化的spring容器的getBean(beanNa me)获取实体bean实例化bean的三种方式（1）：使用默认的构造函数进行实例化bean<bean id=”xxx” class=”xxx.xxx.Xxx”/>（2）：使用静态工厂方法创建bean<bean id=”xxx” class=”xxx.xxx.Xxx” factory-method=”xxxx”/>（3）：使用实例化工厂方法创建bean1,先实例化工厂<bean id=”factory” class=”xxx.xxx.Xxx”/>2,然后实例化bean <bean id=”xxx” class=”xxx.xxx.Xxx” factory-method=”xxxx”/>默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。

Spring各模块相关jar包（依赖）

Spring各模块相关jar包（依赖）Spring框架1、测试单元Test：Spring的单元测试模块；spring-test-xxx.jar 依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.2.3.RELEASE</version></dependency>2、IOC容器Core Container：核⼼容器（IOC）1. spring-beans-xxx.jar 依赖1<dependency>2<groupId>org.springframework</groupId>3<artifactId>spring-beans</artifactId>4<version>5.2.3.RELEASE</version>5</dependency>2. spring-core-xxx.jar依赖1<dependency>2<groupId>org.springframework</groupId>3<artifactId>spring-core</artifactId>4<version>5.2.3.RELEASE</version>5</dependency>3. spring-context-xxx.jar依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.3.RELEASE</version><type>pom</type></dependency>4. spring-expression-xxx.jar依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId><version>5.2.3.RELEASE</version></dependency>2、AOPAop+Aspects(⾯向切⾯编程模块)依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.2.3.RELEASE</version><type>pom</type></dependency>spring-aop-xxx.jar3、DADAO即Data Access缩写，数据访问的意思，其实还有个Integration（集成）数据访问/集成包括了5个部分1. JDBC：Java DataBase Connection 即java数据库连接 spring-jdbc-xxx.jar 依赖1<dependency>2<groupId>org.springframework</groupId>3<artifactId>spring-jdbc</artifactId>4<version>5.2.2.RELEASE</version>5</dependency>2. ORM：Object Relation Mapping 即对象关系映射 spring-orm-xxx.jar 依赖1<dependency>2<groupId>org.springframework</groupId>3<artifactId>spring-orm</artifactId>4<version>5.2.2.RELEASE</version>5</dependency>3. OXM：Object XML Mapping即对象和xml配置⽂件的映射 spring-oxm-xxx.jar依赖1<dependency>2<groupId>org.springframework</groupId>3<artifactId>spring-oxm</artifactId>4<version>5.2.2.RELEASE</version>5</dependency>4. JMS：Java Msg server 即java消息服务 spring-jms-xxx.jar依赖1<dependency>2<groupId>org.springframework</groupId>3<artifactId>spring-jms</artifactId>4<version>5.2.2.RELEASE</version>5</dependency>5. Transactions：即事务 spring-tx-xxx.jar依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>5.2.2.RELEASE</version></dependency>125是跟DA有关系，34是和Integration有关系4、Webweb相关包：1. WebSocket(新的技术) spring-websocket-xxx.jar依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-websocket</artifactId><version>5.2.2.RELEASE</version></dependency>2. Servlet（原⽣web相关） spring-web-xxx.jar依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>5.2.2.RELEASE</version></dependency>3. Web（开发web项⽬web模块）spring-webmvc-xxx.jar依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.2.2.RELEASE</version></dependency>4. Portlet(开发web⼀些组件集成) spring-webmvc-portlet-xxx.jar依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc-portlet</artifactId><version>4.3.21.RELEASE</version></dependency>5、Spring包依赖说明:1) spring-core.jar 依赖commons-collections.jar，spring-core.jar是以下其它各个的基本。

Spring系列之Spring常用注解总结

Spring系列之Spring常⽤注解总结Spring系列之Spring常⽤注解总结传统的Spring做法是使⽤.xml⽂件来对bean进⾏注⼊或者是配置aop、事物，这么做有两个缺点：1、如果所有的内容都配置在.xml⽂件中，那么.xml⽂件将会⼗分庞⼤；如果按需求分开.xml⽂件，那么.xml⽂件⼜会⾮常多。

总之这将导致配置⽂件的可读性与可维护性变得很低。

2、在开发中在.java⽂件和.xml⽂件之间不断切换，是⼀件⿇烦的事，同时这种思维上的不连贯也会降低开发的效率。

为了解决这两个问题，Spring引⼊了注解，通过"@XXX"的⽅式，让注解与Java Bean紧密结合，既⼤⼤减少了配置⽂件的体积，⼜增加了Java Bean的可读性与内聚性。

不使⽤注解：先看⼀个不使⽤注解的Spring⽰例，在这个⽰例的基础上，改成注解版本的，这样也能看出使⽤与不使⽤注解之间的区别，先定义⼀个⽼虎：package com.spring.model;public class Tiger {private String tigerName="TigerKing";public String toString(){return "TigerName:"+tigerName;}}再定义⼀个猴⼦：package com.spring.model;public class Monkey {private String monkeyName = "MonkeyKing";public String toString(){return "MonkeyName:" + monkeyName;}}定义⼀个动物园：package com.spring.model;public class Zoo {private Tiger tiger;private Monkey monkey;public Tiger getTiger() {return tiger;}public void setTiger(Tiger tiger) {this.tiger = tiger;}public Monkey getMonkey() {return monkey;}public void setMonkey(Monkey monkey) {this.monkey = monkey;}public String toString(){return tiger + "\n" + monkey;}}spring的配置⽂件这么写：<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"><bean id="zoo" class="com.spring.model.Zoo"><property name="tiger" ref="tiger"/><property name="monkey" ref="monkey"/></bean><bean id="tiger" class="com.spring.model.Tiger"/><bean id="monkey" class="com.spring.model.Monkey"/></beans>测试⽅法：public class TestAnnotation {/*** 不使⽤注解*/@Testpublic void test(){//读取配置⽂件ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext2.xml");Zoo zoo=(Zoo) ctx.getBean("zoo");System.out.println(zoo.toString());}}都很熟悉，权当复习⼀遍了。

SpringBoot之SpringBootStarter依赖包及作用

SpringBoot之SpringBootStarter依赖包及作⽤spring-boot-starter这是Spring Boot的核⼼启动器，包含了⾃动配置、⽇志和YAML。

spring-boot-starter-amqp通过spring-rabbit来⽀持AMQP协议（Advanced Message Queuing Protocol. 。

spring-boot-starter-aop⽀持⾯向⽅⾯的编程即AOP，包括spring-aop和AspectJ。

spring-boot-starter-artemis通过Apache Artemis⽀持JMS的API（Java Message Service API. 。

spring-boot-starter-batch⽀持Spring Batch，包括HSQLDB数据库。

spring-boot-starter-cache⽀持Spring的Cache抽象。

spring-boot-starter-cloud-connectors⽀持Spring Cloud Connectors，简化了在像Cloud Foundry或Heroku这样的云平台上连接服务。

spring-boot-starter-data-elasticsearch⽀持ElasticSearch搜索和分析引擎，包括spring-data-elasticsearch。

spring-boot-starter-data-gemfire⽀持GemFire分布式数据存储，包括spring-data-gemfire。

spring-boot-starter-data-jpa⽀持JPA（Java Persistence API. ，包括spring-data-jpa、spring-orm、Hibernate。

spring-boot-starter-data-mongodb⽀持MongoDB数据，包括spring-data-mongodb。

spring配置扫描多个包问题解析

spring配置扫描多个包问题解析spring 配置扫描多个包，有时候我们希望不同功能类型的包放在不同的包下，这就需要<context:component-scan base-package="com.weixiao.ssmcleardb.controller" /><context:component-scan base-package="com.weixiao.listener" />有时候我们可能遇到奇怪的问题，新建了⼀个包，在这个包下⾯新建了⼀个类，也添加了注解，但启动的时候就是扫描不到，⽽其它的类⼜正常！这就是你新建的包没有配置为⾃动扫描的原因。

⽐如我在 com.weixiao.listener 包下新建的⼀个类：package com.weixiao.listener;import javax.servlet.ServletContext;import org.apache.log4j.LogManager;import org.apache.log4j.Logger;import org.springframework.beans.BeansException;import org.springframework.beans.factory.InitializingBean;import org.springframework.context.ApplicationContext;import org.springframework.context.ApplicationContextAware;import org.springframework.context.ApplicationListener;import org.springframework.context.event.ContextRefreshedEvent;import ponent;import org.springframework.web.context.ServletContextAware;@Component("StartupListener")public class StartupListener implements ApplicationContextAware, ServletContextAware, InitializingBean,ApplicationListener<ContextRefreshedEvent> {protected Logger logger = LogManager.getLogger(getClass());@Overridepublic void setApplicationContext(ApplicationContext ctx) throws BeansException {("\r\n\r\n\r\n\r\n1 => StartupListener.setApplicationContext");}@Overridepublic void setServletContext(ServletContext context) {("\r\n\r\n\r\n\r\n2 => StartupListener.setServletContext");}@Overridepublic void afterPropertiesSet() throws Exception {("\r\n\r\n\r\n\r\n3 => StartupListener.afterPropertiesSet");}@Overridepublic void onApplicationEvent(ContextRefreshedEvent event) {("\r\n\r\n\r\n\r\n4.1 => MyApplicationListener.onApplicationEvent");("\r\n\r\n\r\n\r\n4.1 => " + event.getApplicationContext().getParent());("\r\n\r\n\r\n\r\n4.1 => " + event.getApplicationContext().getDisplayName());if (event.getApplicationContext().getParent() == null) {("\r\n\r\n\r\n\r\n4.2 => MyApplicationListener.onApplicationEvent");} else{("\r\n\r\n\r\n\r\n4.4 => " + event.getApplicationContext().getParent().getDisplayName());}if (event.getApplicationContext().getDisplayName().equals("Root WebApplicationContext")){("\r\n\r\n\r\n\r\n4.3 => MyApplicationListener.onApplicationEvent");}}}关于 component-scan，我们来看 spring framework 开发⼿册中的⼀段话：Spring 2.5引⼊了更多典型化注解(stereotype annotations)： @Component、@Service和 @Controller。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

核心提示：spring.jar是包含有完整发布的单个jar包，spring.jar中包含除了
spring-mock.jar里所包含的内容外其它所有jar包的内容，因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试，正式应用系统中是用不得这些类的。

除了spring.jar文件，Spring还包括有
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包。

(9) spring-remoting.jar
这个jar文件包含支持EJB、JMS、远程调用Remoting（RMI、Hessian、Burlap、Http Invoker、JAX-RPC）方面的类。

(10) spring-support.jar
这个jar文件包含支持缓存Cache（ehcache）、JCA、JMX、邮件服务（Java Mail、COS Mail）、任务计划Scheduling（Timer、Quartz）方面的类。

(11) spring-web.jar
这个jar文件包含Web应用开发时，用到Spring框架时所需的核心类，包括自动载入WebApplicationContext特性的类、Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。

(12) spring-webmvc.jar
这个jar文件包含Spring MVC框架相关的所有类。

包含国际化、标签、Theme、视图展现的FreeMarker、JasperReports、Tiles、Velocity、 XSLT相关类。

当然，如果你的应用使用了独立的MVC框架，则无需这个JAR文件里的任何类。

(13) spring-mock.jar
这个jar文件包含Spring一整套mock类来辅助应用的测试。

Spring测试套件使用了其中大量mock类，这样测试就更加简单。

模拟HttpServletRequest和HttpServletResponse类在Web应用单元测试是很方便的。

如何选择这些发布包，决定选用哪些发布包其实相当简单。

如果你正在构建Web应用并将全程使用Spring，那么最好就使用单个全部的 spring.jar文件；如果你的应用仅仅用到简单的Inversion of Control / Dependency Injection（IoC/DI）容器，那么只需spring-core.jar 与spring-beans.jar即可；如果你对发布的大小要求很高，那么就得精挑细选了，只取包含自己所需特性的jar文件了。

采用独立的发布包你可以避免包含自己的应用不需要的全部类。

当然你可以采用其它的一些工具来设法令整个应用包变小，节省空间的重点在于准确地找出自己所需的Spring依赖类，然后合并所需的类与包就可以了。

Eclispe有个插件叫 ClassPath Helper可以帮你找找所依赖的类。

Spring包依赖说明:
1) spring-core.jar需commons-collections.jar，spring-core.jar是以下其它各个的基本。

2) spring-beans.jar需spring-core.jar，cglib-nodep-2.1_3.jar
3) spring-aop.jar需spring-core.jar，spring-beans.jar，cglib-nodep-2.1_3.jar，aopalliance.jar
4) spring-context.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，commons-collections.jar，aopalliance.jar
5) spring-dao.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，
spring-context.jar
6) spring-jdbc.jar需spring-core.jar，spring-beans.jar，spring-dao.jar
7) spring-web.jar需spring-core.jar，spring-beans.jar，spring-context.jar
8) spring-webmvc.jar需
spring-core.jar/spring-beans.jar/spring-context.jar/spring-web.jar
9) spring -hibernate.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，spring-
dao.jar，spring-jdbc.jar，spring-orm.jar，spring-web.jar，spring-webmvc.jar
10) spring-orm.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，spring- dao.jar，spring-jdbc.jar，spring-web.jar，spring-webmvc.jar
11) spring -remoting.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，spring- dao.jar，spring-context.jar，spring-web.jar，spring-webmvc.jar
12) spring-support.jar需spring-core.jar，spring-beans.jar，spring-aop.jar，
spring-dao.jar，spring-context.jar，spring-jdbc.jar
13) spring-mock.jar需spring-core.jar，spring-beans.jar，spring-dao.jar，
spring-context.jar，spring-jdbc.jar。