下载文档原格式
对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的引用。
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。
