下载文档原格式
对Spring 框架的学习心得一、概要介绍Spring 框架估计大家都已经了解。
它的目的是解决企业应用开发的复杂性，在功能上是用基本的JavaBean代替EJB，并提供了更多的企业应用功能。
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。
Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式。
现在把Spring主要的并且非常基础的IOC与AOP的应用一些心得给大家介绍一下。
1、核心容器：核心容器提供 Spring 框架的基本功能。
核心容器的主要组件是BeanFactory，它是工厂模式的实现。
BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
2、 Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。
所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。
Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。
通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
这两个方面应该说在Spring中用到的非常广泛。
二、详细介绍1、IOC的说明IoC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。
所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。
从上图可以看到IOC主要包括两个部分的内容，一个是依赖查找、另外一个是依赖注入两个部分。
依赖查找就是容器提供回调接口和上下文环境给组件，例如EJB就是通过这种JNDI的方式进行上下文查找。
示例代码：InitialContext ctx = new InitialContext();Object obj = ctx.lookup(EJBProxy.JNDI);CPTransHome localhome(CPTransHome)PortableRemoteObject.narrow(obj,CPTransHome.class);依赖查找的主要问题是，这段代码必须依赖于JNDI环境，所以它不能在应用服务器之外运行，并且如果要用别的方式取代JNDI来查找资源和协作对象，就必须把JNDI代码抽出来重构到一个策略方法中去。
Spring-全⾯详解（学习总结）⽬录⼀、Spring介绍简介特点、主要特点为什么要学？⼆、IOC（依赖注⼊）Spring 容器IOC 和 bean介绍控制反转：容器概述：bean介绍AOP总结⼀、Spring介绍简介Spring 框架为现代基于 java 的企业应⽤程序提供了⼀个全⾯的编程和配置模型——在任何类型的部署平台上特点、主要特点1、⾮侵⼊式2、容器3、IoC4、AOP5、⽅便程序的测试为什么要学？主流市场推荐、学习的⼈数多、Spring社区活跃、⼯作需要、属于开源框架、⽅便web开发、集成度⾼。
还因为Spring具有以下优点：轻量级：相较于EJB容器，Spring采⽤的IoC容器⾮常的轻量级，基础版本的Spring框架⼤约只有2MB。
Spring可以让开发者们仅仅使⽤POJO(Plain Old Java Object，相对于EJB)就能够开发出企业级的应⽤。
这样做的好处是，你不需要使⽤臃肿庞⼤的 EJB容器(应⽤服务器)，你只需要轻量的servlet容器(如Tomcat)。
尤其在⼀些开发当中，很稀缺内存和CPU资源时，采⽤Spring⽐EJB⽆论是开发还是部署应⽤都更节约资源。
控制反转(IOC)：Spring使⽤控制反转技术实现了松耦合。
依赖被注⼊到对象，⽽不是创建或寻找依赖对象。
⾯向切⾯编程(AOP)： Spring⽀持⾯向切⾯编程，同时把应⽤的业务逻辑与系统的服务分离开来。
MVC框架：Spring MVC是⼀个⾮常好的MVC框架，可以替换其他web框架诸如Struts。
集成性：Spring⾮常容易和其他的流⾏框架⼀起集成开发，这些框架包括：ORM框架，logging框架，JEE, Quartz，以及Struts等表现层框架。
事务管理：Spring强⼤的事务管理功能，能够处理本地事务(⼀个数据库)或是全局事务(多个数据，采⽤JTA)。
模块分离：Spring框架是由模块构成的。
虽然已经有太多的包和类了，但它们都按照模块分好类了，你只需要考虑你会⽤到的模块，⽽不⽤理其他的模块。
spring的有关学习知识总结1.spring是什么?1)它是为属性赋值的一种工具（IOC||DI）当希望一个类调用其它类的的方法时，当在写一个vo时也经常为属性赋值。
2)它是用来处理系统级服务的一种工具(aop)当程序的很多地方都需要同一个服务时，你该怎么办呢？方法调用，不管采用哪种方式，你的程序总要和被调用程序耦合到一起。
为了解决这样问题，spring 提出了自己的方案，什么样的解决方案以后再讲。
3）MVC框架（spring提供了自己MVC模式）4）集成常用框架（hibernate,struts）5）提供了JDBC和DAO的样板代码6)轻量级的框架(整个jar包1M多一点，并且开支非常小)7)非侵入性框架（spring开发出来的项目一般不依赖spring）2.spring是如何为类的属性赋值的呢？它是通过ApplicationContext实现的，那么这个类如何实现的呢，通过xml文件（applicationContext->实例化对象画图）。
3.实例4.理解IOC（获得依赖对象的方式发生反转）依赖注入(Dependency Injection) 容器通过上面实例，在为属性赋值时，不是有由程序自己为属性赋值而是由spring 的类ApplicationContext赋值，这种赋值方式有传统的方法改为spring方式，也就是说赋值的方式发生反转了。
这就是反转控制(Inversion Of Control) 5.赋字符串及基本类型,类对象，内部bean,List或数组,Set,map,Properties,null6.以上程序为属性赋值时，全是生成了get方法和set方法,也就是说spring在赋值时，通过set方法为属性赋值，spring不仅能通过set方法赋值还能通过构造方法为属性赋值。
下面就讲一下，通过构造方法为属性赋值。
表示为构造方法传递一个参数值，那么多参数的构造方法spring如何确定参数的顺序，知道我们可以通过index(从0开始)或通过type(类型的全路径)6.构造与set方法的选择使用set方法比较常用，简单，但是通过set方法赋值的对象不具有强制性，构造方法具有强制性，实例化之后的对象肯定能够使用。
Spring学习总结Spring学习笔记1.Spring的特点（1）轻量级：Spring 是⾮侵⼊性的 - 基于 Spring 开发的应⽤中的对象可以不依赖于 Spring 的 API 依赖注⼊。
（2）(DI --- dependency injection、IOC)。
（3）⾯向切⾯编程(AOP --- aspect oriented programming) 。
（4）容器： Spring 是⼀个容器, 因为它包含并且管理应⽤对象的⽣命周期。
（5）框架：Spring 实现了使⽤简单的组件配置组合成⼀个复杂的应⽤，在 Spring 中可以使⽤ XML 和 Java 注解组合这些对象。
（6）⼀站式：在 IOC 和 AOP 的基础上可以整合各种企业应⽤的开源框架和优秀的第三⽅类库（实际上 Spring ⾃⾝也提供了展现层的SpringMVC 和持久层的 Spring JDBC）。
2.Spring的功能（1）Spring 容器提供了IOC机制，可以创建对象以及管理对象之间的调⽤关系，避免了硬编码造成的程序耦合。
（2）Spring 提供了AOP（⾯向切⾯编程⽅式）功能，可以实现很多特定功能声明式事务控制处理。
（3）Spring对JDBC进⾏了轻量级的封装，可以更加灵活的去操作数据库。
（4）Spring提供了MVC设计模式的解决⽅案（5）Spring提供了⽂件上传、定时器等常⽤⼯具类。
（6）Spring提供了对于其他优秀框架的⽀持（如：Struts、Hibernate、MyBatis、Quartz等）。
3.Spring体系结构1.core containera.beans与core 它们提供spring框架最基本功能，包含ioc与di。
b.context 上下⽂对象，基于beans与cores。
c.spel它是spring提供的⼀个表达式语⾔。
2.Data access/integrationd.数据访问。
spring框架学习的要点总结1.重要的概念重要程度概念说明*****IOC 控制反转，将原来在代码中手动创建对象（也就是new）的操作，反转到由spring容器来进行创建并进行管理。
目的：解耦。
*****DI 依赖注入，由spring容器根据所管理的bean之间的依赖关注，自动进行注入赋值，替代了原来手动给对象属性赋值的操作。
要点：依赖的双方必须都由spring容器来进行管理。
目的：解耦。
*****AOP 面向切面编程：意为将原来散落在系统中的重复性的功能代码抽取出独立的组件进行封装，然后使用动态代理的方式在不修改目标对象的情况下对其进行功能增强，可以实现可插拨式的编程，增加功能和去掉增强的功能对目标对象来说都是无感知的，基本上可以实现零耦合。
目的：解耦、可重用、更灵活。
*****Spring事务又称为声明式事务：主要解决业务层中包含多个持久层方法的调用时，如何来保证这些持久层方法要么同时执行，要么同时回滚，从而保证事务执行的一致性。
目的：在业务层来管理统一事务。
2.学习的注解重要程度注解作用作用的地方*****@Component实例化Bean类上*****@Service实例化Bean业务类上***@Repository实例化Bean持久化类上*****@Controller实例化Bean WEB组件上**@Scope设置bean单例或多例类上**@PostContructor声明初始化方法方法上**@PreDestroy声明销毁方法方法上*****@Autowired自动按类型注入属性属性上**@Qualifier 按名字注入,配置合@Autowired使用属性或形参中**@Resource按名字注入属性上重要程度注解作用作用的地方*****@Value注入基本数据类型属性上*****@Bean 实例化第三方法bean，将方法的返回值放入IOC容器中管理配置类的方法上*****@Configuration声明配置类配置类上*****@ComponentScan 声明扫描指定包下所有的注解并进行解析执行配置类上*****@PropertySource 指定引入properties属性文件并进行加载配置类上*****@Import合并配置类配置类上*****@RunWith指定运行器测试类上*****@ContextConfiguration 用于指定测试时加载的配置类或配置文件测试类上*****@EnableAspectJAutoProxy开启注解开发AOP功能配置类上*****@Aspect设置当前类为通知类通知类上*****@Pointcut生命切点表达式私有空方法上**@Before 前置通知：目标方法执行前执行通知方法上**@AfterReturning 后置通知：目标方法正常执行后执行通知方法上**@AfterThrowing 异常通知：目标方法抛出异常后执行通知方法上**@After 最终通知：目标方法执行成功与否均执行通知方法上*****@Around 环绕通知：可以在目标方法执行前后执行通知方法上*****@EnableTransactionManagement开启注解式事务驱动配置类上*****@Transactional 声明当前业务方法或当前类的所有方法均由spring管理事务接口、实现类或具体方法上。
Spring框架的优点都有什么？1.Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分2.Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高3.依赖注入和IoC使得JDBC操作简单化4.Spring是开源的免费的5.Spring使得对象管理集中化合简单化描述一下Spring中实现DI（Dependency Injection）的几种方式方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。
方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入简述你对IoC（Inversion of Control）的理解一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C的实例，但这种方法显然两者的依赖（Dependency）太大了。
而IoC的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的实现C放入 IoC的容器（Container）中，通过一定的配置由容器（Container）来实现类A与接口B的实现C的关联。
Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法。
在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承 HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。
在使用中如果遇到 OpenSessionInView的问题，可以添加OpenSessionInViewFilter或 OpenSessionInViewInterceptor。
Spring学习一、Spring 框架的相关介绍1.1、Spring 框架的作用：Spring是一个容器性质的框架.可以管理Bean对象的创建和销毁。
Spring容器具有IoC和AoP特性。
1.2、Ioc和Aop的概念IoC : Inverse of Controll 反向控制或控制反转。
AoP : Aspect of Programming 切面编程。
1.3、Spring容器的对象管理引入spring.jar和commons-logging.jar两个基本包。
1、创建容器配置文件,添加<bean>的定义<bean id="别名" class="包名.类名"/>2、创建容器对象,获取bean对象ApplicationContext ctx =new ClassPathXmlApplicationContext("applicationContext.xml")；ctx.getBean("别名")；1.4、使用工厂方式创建对象1、容器通过反射创建2、工厂方法3、静态工厂方法1.5、对象的生命周期1、对象创建时机默认是在容器创建时,将对象创建出来。
可以在<bean/>元素中使用lazy-init="true",将该对象指定为使用时创建。
2、指定对象初始化和销毁方法可以在<bean/>元素中使用init-method="方法名"指定初始化方法可以在<bean/>元素中使用destroy-method="方法名"指定销毁方法,次属性只对单例模式有效。
init方法在创建对象时执行,destroy方法在销毁容器时执行。
3、默认情况下,容器创建的对象的模式是一个单例模式。
可以在<bean/>元素中使用scope指定创建模式.默认为singleton,可以指定为prototype。
一、Spring入门体验小实例注意：用spring之前要将相应spring包导进来,然后bulid path才能用spring来开发。
Code:package com.service;public class ByeService{private String name;public String getName() {return name;}public void setName(String name) { = name;}public void sayBye(){System.out.println("Lily say byebye to "+name);}}package com.service;public class UserService {private String name;private ByeService byService;public ByeService getByService() {return byService;}public void setByService(ByeService byService) {this.byService = byService;}public String getName() {return name;}public void setName(String name) { = name;}public void sayHello() {System.out.println("Lily"+" say hello to "+name);byService.sayBye();}}package com.test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext; import erService;public class Test {public static void main(String[] args) {// TODO Auto-generated method stub//使用传统方法来调用UserService的sayHello方法/* UserService userService = new UserService();userService.setName("小丽");userService.sayHello();*///现在用spring来完成上面的任务//1.得到spring的applicationContext对象ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");//从ac（代表容器applicationContext)中取得对应的beanUserService us =(UserService) ac.getBean("userService");us.sayHello();//从ac（代表容器applicationContext)中取得对应的bean/*ByeService byeService = (ByeService) ac.getBean("byeService");byeService.sayBye();*/}}XML:<?xml version="1.0" encoding="utf-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><!-- 在容器文件中配置bean(service/dao/domain/action/数据源) --><!-- bean元素的作用是，当我们的spring框架加载的时候，spring就会自动创建一个bean对象，并放入内存相当于执行了:UserService userService = new UserService;userService.setName("小丽");--><bean id="userService" class="erService"><!-- 这里就体现了注入的概念 --><property name="name"><value>小丽</value></property><!-- 在userService中引用 byeService bean --><property name="byService" ref="byeService"/></bean><bean id="byeService" class="com.service.ByeService"><!-- 下面这种给值方式和上面是一个效果，都可以 --><property name="name" value="小鱼"/></bean></beans><!--spring容器不但可以配置bean、注入属性，而且还可以维护bean与bean之间的关系 -->Result:Lily say hello to 小丽Lily say byebye to 小鱼二、什么是Spring和IOC？Spring其实就是一个容器框架，用于配置bean并维护bean之间关系的框架。
Spring学习总结（四）——表达式语⾔SpringExpressionLanguage<properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring.version>4.3.0.RELEASE</spring.version></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><scope>test</scope><version>4.10</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.8.9</version></dependency><dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.2.4</version></dependency></dependencies></project>表达式语⾔所依赖的包如下所⽰：2.2、为了IOC，定义了⽤户类User.java与Order.java，如下所⽰：⽤户类：package com.zhangguo.Spring053.spel01;/*** 订单类**/public class Order {/*** 订单名称*/private String orderName;/** ⽤户姓名*/private String userName;/*** ⽤户对象*/private User customer;public String getOrderName() {return orderName;}public void setOrderName(String orderName) {this.orderName = orderName;}public User getCustomer() {return customer;}public void setCustomer(User customer) {this.customer = customer;}public String getUserName() {return userName;}public void setUserName(String userName) {erName = userName;}@Overridepublic String toString() {return "订单名："+this.getOrderName()+",姓名："+this.getUserName()+",编号："+this.getCustomer().getId(); }}View Code订单类：package com.zhangguo.Spring053.spel01;/*** 订单类**/public class Order {/*** 订单名称*/private String orderName;/** ⽤户姓名*/private String userName;/*** ⽤户对象*/private User customer;public String getOrderName() {return orderName;}public void setOrderName(String orderName) {this.orderName = orderName;}public User getCustomer() {return customer;}public void setCustomer(User customer) {this.customer = customer;}public String getUserName() {return userName;}public void setUserName(String userName) {erName = userName;}}View Code2.3、编写容器初始化的配置⽂件spel01.xml，内容如下：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:p="/schema/p"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/aop/schema/aop/spring-aop-4.3.xsd"><bean id="gyl" class="er" p:id="9527"><property name="name" value="郭永乐"></property></bean><bean id="order001" class="com.zhangguo.Spring053.spel01.Order"><property name="customer" ref="gyl"></property><property name="name" value="#{}"></property><property name="orderName" value='#{"Apples".toUpperCase()}'></property></bean></beans>在配置⽂件中，出现了#｛｝形式的表达式，我们就称为Spel表达式。
Spring总结笔记（轻量级框架）1：Spring概述Spring由7个良好的模块构成：Spring AOP(面向切面编成) ,Spring ORM（对象关系模型，包含了与数据库持久化密切相关的技术如：Hibernate）, Spring Web ,Spring Context,Spring DAO,Spring Web MVC，Spring Context（配置文件，为Spring 框架提供上下文文件）和Spring Core.2：Spring的核心思想是：控制反转（Inversion of Control,IoC）和依赖注入（Dependency Injection,DI）控制反转：就是应用本身不负责以来对象的创建及维护，以来对象的创建及维护是由外部容器负责的，这样控制权就由应用转到了外部容器，控制权的转移即为反转。
依赖注入：就是指在运行期间有外部容器动态的依赖对象注入到组件（有本质上它们是同种思想的不同说法）有三种依赖注入方式：1：接口注入2：set注入3：构造注入提示：set注入与构造注入比较类似，如果是在动态的不确定的环境下需要注入一个对象，没有必要调用构造函数而实例化一个对象，所以此时应set注入。
3：Bean与Sring极端的讲Spring=Beans+XML在Spring中的所有组件都会被认为是一个Bean，Bean是容器管理的一个基本单位，bean比一定都是标准的JavaBean，可以是数据源（如Hibernate的SessionFactory）。
Spring通过叫BeanFactory（实现了工厂模式）的容器对bean进行管理。
BeanFactory包含的基本方法：public Object getBean（String name）：根据名称返回bean实例public Object getBean（String name，Class requiredType）：根据名称和类型返回bean实例4：XML文件中配置Bean<bean id="HelloWorld" class="com.spring.text.HelloWorld"scope="prototype"></bean>id:是BeanFactory中存在的一个标识，可以通过它找到这个Bean的引用。
控制反转(IoC)：spring容器根据配置文件信息，负责创建某类实例，并为实例设置属性值——这种由spring 容器为对象设置属性的方式被称为控制反转Spring的核心机制：依赖注入当某个java实例需要其他java实例时，系统自动提供所需要的实例，无需程序显式获取使用依赖注入不仅可以为Bean注入普通的属性值，还可以注入其他Bean的引用所谓依赖注入，就是在在运行期间，有外部容器动态地将依赖对象注入到组件中（构造方法和set方法)不管是控制反转还是依赖注入，其含义完全相同：当某个java实例（调用者）需要另一个java实例（被调用者）时，在传统的程序设计过程中，在传统的程序设计当中，通常由调用者来创建被调用者的实例在依赖注入的模式下，创建被调用者的工作不再由调用者来完成，因此称为控制反转；创建被调用者实例的工作通常是由spring容器来完成，然后注入调用者，因此也称为依赖注入依赖注入通常有两种：1）设值注入：设值注入是指IoC容器使用属性的setter方法来注入被依赖的实例2）构造注入：这种利用构造器来设置依赖关系的方式，被称为构造注入两种注入方式的区别：创建Person实例中Axe属性的时机不同——设值注入是先通过无参数的构造器创建一个bean实例，然后调用对应的setter方法注入依赖关系；而构造注入则直接调用有参数的构造器，当bean实例创建完成后，已经完成了依赖关系的注入Spring提供的服务1）事物管理服务2）JMS服务（Java消息服务是基于java的消息中间件、是javaEE的一部分、用于在多个Java应用之间发送消息、该机制使得多个分布式应用可以异步通信、提高软件可靠性、降低耦合度）3）Spring core核心服务4）持久化服务ApplicationContext事件机制：Spring的事件机制与所有的事件机制都基本相似，它们都需要事件源、事件、事件监听器，此处的事件源是ApplicationContext，且事件必须有java程序显式触发Spring事件框架有两个重要成员：1）ApplicationEvent：容器事件，必须由ApplicationContext发布2）ApplicationListener：监听器，可由容器中的任何监听器bean担任通过ApplicationEvent类和ApplicationListener接口，可实现ApplicationContext的事件处理如果容器中有一个ApplicationListener Bean，每当ApplicationContext发布ApplicationEvent时，ApplicationListener Bean将自动被触发在默认情况下，当spring创建ApplicationContext容器时，Spring会自动预初始化容器中所有的singleton实例，如果我们不想让Spring容器预初始化某个singleton Bean，则可为该<bean…/>元素增加lazy-init属性，指定该属性为true，则Spring不会预初始化该Bean实例，如下面配置文件所示：<bean id=”bean2” class=”lee.Test2” lazy-init=”true”/>容器中Bean的作用域当通过Spring容器创建一个Bean实例时，不仅可以完成Bean实例的实例化，还可以为Bean指定特定的作用域，Spring支持如下的5种作用域1）singleton：单例模式，在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例2）prototype：原型模式，每次通过容器的getBean方法获取prototype定义的Beans时，都将产生一个新的Bean实例3）request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求都将会产生不同的Bean实例。
Spring总结历史背景：Spring是一个兴起于2003轻量级java开发框架.它的最初目的：为了简化java EE企业级应用开发.框架特点：●Spring着重提供一种管理业务的对象方法.●Spring全面的，模块化的，采用分层架构（因为不同的分层有不同的注解）●Spring设计之初就是帮助你写出易于测试的代码.是一个测试驱动项目的理想框架.●Spring是一个集成技术，得到广泛的认可.●Spring不需要依赖任何框架，”一站式服务”.框架优缺点：优点：1.Spring有效的组织中间层对象.2.Spring消除很多项目中所常见的单例过度的使用.降低了可测试性和面向对象的程序。
3.Spring通过应用程序和项目之间一致的方法来处理配置.消除了自定义配置文件格式的烦恼.4.Spring 通过针对接口而非类编码代价几乎为零，给编写者养成良好的编码习惯.5.Spring在设计构建它之上的应用程序尽可能少依赖于SpringAPI.6.构建在Spring之上的应用程序易于单元测试.7.Spring在你不使用EJB帮你解决很多问题.Spring能提供一种适用于很多应用程序的EJB的替代品.8.Spring 使得是否使用EJB 成为实现时的选择，而非架构上的决定。
9.Spring 为数据访问提供了一个一致的框架10.Spring 为很多方面提供了一种一致的简单的编程模型( JDBC、JMS、JavaMail、JNDI)11.Spring 是一种帮助你使用POJO 来构建应用程序的基础技术.缺点：Spring 中没有日志，没有连接池，没有分布式事务调度。
Spring做了些什么：1.Spring主要目的是使J2ee更易于使用，培养好的编程习惯.2.Spring引用现有的资源，比如（log4j 连接池分布式事务调用）3.Spring致力于现有技术更加易用，不与其他技术进行竞争.4.Spring 得益与内部一致性.5.Spring可用于各种应用服务器.Spring分为6大块：Core封装包是框架最基础部分，提供IOC和依赖注入特性.Context(上下文)封装包构筑于Core封装包的基础上，它提供了一种框架风格方式来访问对象.Dao提供了JDBC的抽象层，它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码.ORM封装包提供了常用的对象/关系映射APIs的集成层. AOP封装包提供了符合AOP Alliance 规范的面向方面的编程实现.WEB包提供了基础的针对Web开发的集成特性.MVC封装包提供了Web应用Model-view-Controller实现. Spring流程：由客户端发送请求，经过Spring前控制器，前控制器把请求发送给自定义控制器，进行处理请求数据，根据请求数据创建ModelAndView，然后根据请求响应模型或页面给主控制器，主控制器根据模型进行验证，控制响应模型响应给主控制器，主控制器响应给客户端.Spring MVC:Spring的MVC围绕DispatchServlet设计，dispatch的作用是将请求分发到不同的处理器.框架特点：1.清晰的角色划分：控制器，验证器，表单对象，命令对象，模型对象，Servlet分发器，分发器映射，视图解析器.2.强大而直接的配置：框架类，应用程序类都使用javabean来配置.3.可适配，非侵入：simple型,command型，from型.4.可重用的业务代码：可以使用现有的对象作为表单或业务对象.5.可定制绑定和验证.6.可定制处理映射和页面决定.7.灵活的模型转换.通过Map来达到视图技术的集成.8.可定制本地化和主题解析：支持JSTL，Spring（from,tags）等标签语言.9.Spring Bean 的生命周期可以被限制在当前的HTTP Request 或者HTTPSession。
前边讲述了用于处理数据流程的Struts2的框架，和用于操作数据的IBatis持久层框架，这篇博客开始总结一下Spring框架，是进行对象管理，对象关联，解耦的一个中间层框架。
SSH（Struts+Spring+Hibernate）三大Spring在中间就起着一个承上启下的作用。
好，首先我们先来看一下Spring框架的一些知识点，通过下边这张图来总括一下：好，这篇博客咱们先来对Spring框架进行一个初步的了解。
一，框架介绍：1，先看一下帮助文档的这张图，里边主要包括了Spring自身的功能，还有可以和其框架结合的一些框架，通过这张图可以看出，Spring 框架和其他框架的集成能力是非常强的。
2，Spring是一个轻量级的IOC和AOP容器框架：a,轻量级：程序实现不是很复杂，代码不是很多，占用资源不是很多，没有侵入性；b，IOC（Inver sion of Control 控制反转）：对象创建责任的反转（重点，核心）；c, Aop(Aspect Oriented Programming):一种面向横切面编程的思想方式，可以进行功能性扩展，看前边的一篇转载的博客：面向横切面（AOP）编程d，容器：可以容纳对象，并且可以控制对象的生命周期；二，看一下使用步骤吧！（框架用多了，感觉步骤都大同小异）1，还是拷贝jar包：2，拷贝框架的核心配置文件，存放在src目录下：3，编写框架的核心配置文件，将声明对象都交给Spring框架来创建，以及初始化，例如service层的类，action层类，dao层类等等，都可以交给Spring进行管理，看一个例子：[html]view plain copyprint?1.<span style="font-size:18px;"><!-- 声明Action对象 -->2.3.<bean id="loginAction"class="com.ljh.struts2.action.LoginAction"scope="prototype"></bean></span>分析：a，框架创建对象的方式：框架默认创建对象是单例的：scope="singleton"当然action我们想要多例创建，需要设置：scope="prototype"b,工厂BeanFactory,，如果使用BeanFactory来加载Spring配置文件，那么是在调用getBean时，框架调用对象的默认构造方法来创建对象。
---------------------------------------------------------------最新资料推荐------------------------------------------------------Spring 总结.Spring 框架主讲：梁健全以下笔记均为我本人亲自整理，若有描述不对或代码错误，请同学们及时更改一下，重新上传上去，谢谢！ 1.Spring 框架作用和优点 Spring 框架主要负责进行技术整合，例如整合Struts2、 Hibernate、 JDBC 等技术。
优点是：可以提高程序结构灵活性、降低组件之间的耦合度，便于日后的扩展和维护。
2.Spring 框架主要功能 a.Spring 框架提供了一个核心容器，该容器可以负责管理程序中的 DAO、 Action 等组件*b.Spring 框架提供了对 Struts2、 Hibernate、 JDBC 技术整合的API c.Spring 框架提供了 IOC 机制，可以降低两个组件之间调用的耦合度 d.Spring 框架提供了 AOP 机制，可以降低共通组件和一批目标组件的耦合度。
*e.Spring 框架提供了事务管理功能，只需要做一些 AOP 配置即可。
*3.Spring 框架容器 Spring 框架容器可以管理 DAO、Action 等 Bean 组件。
该容器具有以下功能：a.可以创建 Bean 组件对象b.可以初始化 Bean 组件对1/ 16象 c.可以销毁 Bean 组件对象 d.容器具有 IOC 和 AOP 机制--引入spring-ioc 开发包--在src 下添加applicationContext.xml 配置--将DAO 等组件定义到applicationContext.xml中，定义格式bean id= 标识符class= 包名 . 类名/bean *1)Spring 容器基本使用步骤 --实例化 Spring 容器对象 BeanFactory--ApplicationContext(子类) new ClassPathXmlApplicationContext(容器配置文件); --通过容器对象.getBean(标识符)获取 Bean 实例。
Spring注解基础学习总结1.依赖注⼊注解： @Component：Bean注⼊到Spring容器组件（通⽤） @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)：Bean作⽤域（ SCOPE_PROTOTYPE：每次注⼊bean就是⼀个新的Bean SCOPE_SINGLETON：单例） @Repository：标记该类为Dao数据访问层 @Service：标记该类为Service业务逻辑层 @Controller：标记该类为Controller控制访问层 @Autowired注解：⾃动装配bean使⽤说明：该注解可以放在构造⽅法上，注⼊属性上，普通⽅法上 属性：required = false（如果该类没有在Spring容器中则忽略不报错） 歧义性：@Qualifier作⽤⽐@Primary强/*** Created by ⼩⼩⾼ on 19-7-14** 学习Spring bean注⼊* @Component注解：* 标记这个类为组件，进⾏注⼊bean** @Autowired注解：⾃动装配bean* 使⽤说明：该注解可以放在构造⽅法上，注⼊属性上，普通⽅法上*/@Data@Component@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)//@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)public class SpringTestBeanClass {private String name;private Integer age;private String id;@Autowiredprivate SpringBeanSonClass02 springBeanSonClass;// @Autowired/*注⼊bean到构造⽅法*/// public SpringTestBeanClass(SpringBeanSonClass springBeanSonClass){// this.springBeanSonClass = springBeanSonClass;// }// @Autowired/*注⼊bean到普通⽅法*/// public void setSpringBeanSonClass(SpringBeanSonClass springBeanSonClass){// this.springBeanSonClass = springBeanSonClass;// }public void pay(){System.out.println("调⽤SpringTestBeanClass类的pay⽅法");springBeanSonClass.springBeanSonClass02();}} @Configuration：标记该类为配置类* @Configuration注解；声明该类为配置类，加载Spring容器* 使⽤说明：* @Configuration注解的配置类有如下要求：* 1.@Configuration不可以是final类型；* 2.@Configuration不可以是匿名类；* 3.嵌套的configuration必须是静态类。
spring总结Spring是一个开源的Java开发框架，旨在简化企业级Java应用程序的开发。
它提供了一套全面的功能，用于构建灵活、可伸缩的应用程序。
在过去的几年里，Spring已经成为Java开发者首选的框架之一。
本文将总结Spring的核心特性、优势以及如何使用它来开发高效的Java应用程序。
Spring的核心特性包括依赖注入（Dependency Injection，DI）、切面编程（Aspect Oriented Programming，AOP）和面向切面编程（Aspect-Oriented Programming，AOP）。
其中，依赖注入允许开发者将应用程序的依赖从代码中分离出来，使得组件之间的协作更加灵活。
切面编程允许开发者将与业务逻辑无关的代码（如日志记录、事务管理等）集中到一个地方，提高代码的可维护性。
面向切面编程则是一种扩展切面编程的方式，允许在运行时动态地将切面织入到应用程序中。
除了核心特性外，Spring还提供了许多其他功能，如事务管理、数据访问、Web开发等。
事务管理是Spring的一个重要特性，它为开发者提供了一个统一的方式来管理数据库事务。
这能够确保数据的一致性和完整性。
数据访问是另一个重要的功能，Spring提供了一个轻量级的ORM框架，使得开发者可以更加简单地与数据库进行交互。
此外，Spring还提供了一套全面的Web开发框架，使得开发者可以轻松地构建可扩展的Web应用程序。
Spring的优势主要体现在以下几个方面。
首先，Spring提供了一个模块化的架构，开发者可以根据实际需要选择适合自己的模块。
这样可以减少项目的依赖，提高代码的灵活性。
其次，Spring提供了一个丰富的生态系统，包括许多常用的库和工具。
这些库和工具可以与Spring框架无缝集成，使得开发者更加容易构建复杂的应用程序。
再次，Spring提供了强大的测试支持，开发者可以使用JUnit等测试框架来测试他们的Spring应用程序。
1. Spring实现AOP的4种方式AOP的相关术语1.通知(Advice):通知定义了切面是什么以及何时使用。
描述了切面要完成的工作和何时需要执行这个工作。
2.连接点(Joinpoint):程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。
3.切入点(Pointcut)通知定义了切面要发生的“故事”和时间，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名称，spring中允许我们方便的用正则表达式来指定4.切面(Aspect)通知和切入点共同组成了切面：时间、地点和要发生的“故事”5.引入(Introduction)引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能）6.目标(Target)即被通知的对象，如果没有AOP,那么它的逻辑将要交叉别的事务逻辑，有了AOP之后它可以只关注自己要做的事（AOP让他做爱做的事）7.代理(proxy)应用通知的对象，详细内容参见设计模式里面的代理模式8.织入(Weaving)把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机:(1)编译时：当一个类文件被编译时进行织入，这需要特殊的编译器才可以做的到，例如AspectJ的织入编译器(2)类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码(3)运行时：切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的，原理应该是使用了JDK的动态代理技术Spring提供了4种实现AOP的方式：1.经典的基于代理的AOP2.@AspectJ注解驱动的切面3.纯POJO切面4.注入式AspectJ切面首先看经典的基于代理的AOP:Spring支持五种类型的通知：Before(前) org.apringframework.aop.MethodBeforeAdviceAfter-returning(返回后) org.springframework.aop.AfterReturningAdviceAfter-throwing(抛出后) org.springframework.aop.ThrowsAdviceArround(周围) org.aopaliance.intercept.MethodInterceptorIntroduction(引入) org.springframework.aop.IntroductionInterceptor值的说明的是周围通知，他是由AOP Alliance中的接口定义的而非Spring,周围通知相当于前通知、返回后通知、抛出后通知的结合（传说中的完全体？好吧，我看日和看多了）还有引入通知怎么玩我还没搞清楚，等心无杂念的时候玩玩这东西怎么玩？这么几个步骤：1.创建通知：实现这几个接口，把其中的方法实现了2.定义切点和通知者：在Spring配制文件中配置这些信息3.使用ProxyFactoryBean来生成代理具体做法。
大晚上的就举个睡觉的例子吧:首先写一个接口叫Sleepable,这是一个牛X的接口,所有具有睡觉能力的东西都可以实现该接口（不光生物，包括关机选项里面的休眠）package test.spring.aop.beanpublic interface Sleepable{void sleep();}然后写一个Human类，他实现了这个接口package test.spring.aop.beanpublic Human implements Sleepable{/*这人莫非跟寡人差不多？*除了睡觉睡的比较好之外其余的什么也不会做？*/public void sleep(){System.out.println("睡觉了！梦中自有颜如玉！");}}好了，这是主角，不过睡觉前后要做些辅助工作的，最基本的是脱穿衣服，失眠的人还要吃安眠药什么的,但是这些动作与纯粹的睡觉这一“业务逻辑”是不相干的，如果把这些代码全部加入到sleep方法中，是不是有违单一职责呢？，这时候我们就需要AOP了。
编写一个SleepHelper类，它里面包含了睡觉的辅助工作,用AOP术语来说它就应该是通知了，我们需要实现上面的接口然后在spring配置文件中进行配置:<bean id="sleepHelper" class="test.spring.aop.bean.SleepHelper"></bean>OK!现在创建通知的工作就完成了.第二步是进行配置首先要做的是配置一个切点,据说切点的表示方式在Spring中有好几种，但是常用的只有两种：1.使用正则表达式2.使用AspectJ表达式AspectJ我不是很熟悉,我还是习惯用正则表达式Spring使用org.springframework.aop.support.JdkRegexpMethodPointcut来定义正则表达式切点<bean id="spleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut"><property name="pattern" value=".*sleep"/></bean>pattern属性指定了正则表达式，它匹配所有的sleep方法切点仅仅是定义了故事发生的地点，还有故事发生的时间以及最重要的故事的内容,就是通知了，我们需要把通知跟切点结合起来，我们要使用的通知者是:org.springframework.aop.support.DefaultPointcutAdvisor<bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor"><property name="advice" ref="sleepHelper"/><property name="pointcut" ref="sleepPointcut"/></bean>切入点和通知都配置完成，接下来该调用ProxyFactoryBean产生代理对象了<bean id="humanProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="target" ref="human"/><property name="interceptorNames" value="sleepHelperAdvisor" /><property name="proxyInterfaces" value="test.spring.aop.bean.Sleepable" /></bean>ProxyFactoryBean是一个代理，我们可以把它转换为proxyInterfaces中指定的实现该interface的代理对象:import org.springframework.aop.framework.ProxyFactoryBean;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import test.spring.aop.bean.Sleepable;public class Test {public static void main(String[] args){ApplicationContext appCtx = new ClassPathXmlApplicationContext("applicationContext.xml");Sleepable sleeper = (Sleepable)appCtx.getBean("humanProxy");sleeper.sleep();}}程序运行产生结果：通常情况下睡觉之前要脱衣服！睡觉啦~梦中自有颜如玉!起床后要先穿衣服！OK!这是我们想要的结果，但是上面这个过程貌似有点复杂，尤其是配置切点跟通知,Spring 提供了一种自动代理的功能，能让切点跟通知自动进行匹配，修改配置文件如下:<bean id="sleepHelper" class="test.spring.aop.bean.SleepHelper"></bean><bean id="sleepAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice" ref="sleepHelper"/><property name="pattern" value=".*sleep"/></bean><bean id="human" class="test.spring.aop.bean.Human"></bean><bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>执行程序：public class Test {public static void main(String[] args){ApplicationContext appCtx = new ClassPathXmlApplicationContext("applicationContext.xml");Sleepable sleeper = (Sleepable)appCtx.getBean("human");sleeper.sleep();}}成功输出结果跟前面一样!只要我们声明了org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator就能为方法匹配的bean自动创建代理！但是这样还是要有很多工作要做,有更简单的方式吗?有！一种方式是使用AspectJ提供的注解:package test.mine.spring.bean;import ng.annotation.AfterReturning;import ng.annotation.Aspect;import ng.annotation.Before;import ng.annotation.Pointcut;@Aspectpublic class SleepHelper {public SleepHelper(){}@Pointcut("execution(* *.sleep())")public void sleeppoint(){}@Before("sleeppoint()")public void beforeSleep(){System.out.println("睡觉前要脱衣服!");}@AfterReturning("sleeppoint()")public void afterSleep(){System.out.println("睡醒了要穿衣服！");}}用@Aspect的注解来标识切面,注意不要把它漏了，否则Spring创建代理的时候会找不到它,@Pointcut注解指定了切点，@Before和@AfterReturning指定了运行时的通知，注意的是要在注解中传入切点的名称然后我们在Spring配置文件上下点功夫,首先是增加AOP的XML命名空间和声明相关schema命名空间:xmlns:aop="/schema/aop"schema声明:/schema/aop/schema/aop/spring-aop-2.0.xsd然后加上这个标签:<aop:aspectj-autoproxy/>有了这个Spring就能够自动扫描被@Aspect标注的切面了最后是运行，很简单方便了：public class Test {public static void main(String[] args){ApplicationContext appCtx = new ClassPathXmlApplicationContext("applicationContext.xml");Sleepable human = (Sleepable)appCtx.getBean("human");human.sleep();}}下面我们来看最后一种常用的实现AOP的方式:使用Spring来定义纯粹的POJO切面前面我们用到了<aop:aspectj-autoproxy/>标签,Spring在aop的命名空间里面还提供了其他的配置元素:<aop:advisor>定义一个AOP通知者<aop:after>后通知<aop:after-returning>返回后通知<aop:after-throwing>抛出后通知<aop:around>周围通知<aop:aspect>定义一个切面<aop:before>前通知<aop:config>顶级配置元素，类似于<beans>这种东西<aop:pointcut>定义一个切点我们用AOP标签来实现睡觉这个过程:代码不变，只是修改配置文件,加入AOP配置即可:<aop:config><aop:aspect ref="sleepHelper"><aop:before method="beforeSleep" pointcut="execution(* *.sleep(..))"/><aop:after method="afterSleep" pointcut="execution(* *.sleep(..))"/> </aop:aspect></aop:config>2.事务配置∙首先在/WEB-INF/applicationContext.xml添加以下内容：<!-- 配置事务管理器 --><bean id="transactionManager"class="org.springframework.orm.hibernate3 .HibernateTransactionManager"><property name="sessionFactory"><ref bean="mySessionFactory"/></property></bean>注：这是作为公共使用的事务管理器Bean。
