Spring框架知识点详解

一、概述

1.1Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。且可以和其他框架一起使用；Spring与Struts,  Spring与hibernate(起到整合（粘合）作用的一个框架)

1.2Spring提供了一站式解决方案：

         1） Spring Core  spring的核心功能： IOC容器, 解决对象创建及依赖关系

         2） Spring Web  Spring对web模块的支持。

•      可以与struts整合,让struts的action创建交给spring
•      spring mvc模式

         3） Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】

         4） Spring ORM  spring对orm的支持：

•       既可以与hibernate整合，【session】
•       也可以使用spring的对hibernate操作的封装

         5）Spring AOP  切面编程

         6）SpringEE   spring 对javaEE其他模块的支持

二、开发步骤

2.1spring各个版本中：

         在3.0以下的版本，源码有spring中相关的所有包【spring功能 + 依赖包】

                   如2.5版本；

         在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】

                   (如果要用依赖包，需要单独下载！)

2.2 源码, jar文件：spring-framework-3.2.5.RELEASE

 commons-logging-1.1.3.jar           日志

spring-beans-3.2.5.RELEASE.jar        bean节点

spring-context-3.2.5.RELEASE.jar       spring上下文节点

spring-core-3.2.5.RELEASE.jar         spring核心功能

spring-expression-3.2.5.RELEASE.jar    spring表达式相关表

以上是必须引入的5个jar文件，在项目中可以用户库管理！

2.3核心配置文件: applicationContext.xml 

         Spring配置文件：applicationContext.xml / bean.xml

2.4约束参考：

spring-framework-3.2.5.RELEASEdocsspring-framework-referencehtmlsingleindex.html

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd">

   

</beans>  

2.5Api 

public class App {

    // 1. 通过工厂类得到IOC容器创建的对象
    @Test
    public void testIOC() throws Exception {
        // 创建对象
        // User user = new User();
        // 现在，把对象的创建交给spring的IOC容器
        Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");
        // 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
        BeanFactory factory = new XmlBeanFactory(resource);
        // 得到容器创建的对象
        User user = (User) factory.getBean("user");
        System.out.println(user.getId());
    }

    //2. （方便）直接得到IOC容器对象
    @Test
    public void testAc() throws Exception {
        // 得到IOC容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
        // 从容器中获取bean
        User user = (User) ac.getBean("user");
        System.out.println(user);
    }
}

三、 bean对象创建的细节

3.1创建对象

SpringIOC容器，是spring核心内容。

作用： 创建对象 & 处理对象的依赖关系

IOC容器创建对象：

创建对象, 有几种方式：

                                   1）调用无参数构造器

                                   2）工厂创建对象

                   　　　　　　　　　　　　工厂类，静态方法创建对象

                   　　　　　　　　　　　　工厂类，非静态方法创建对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- ###############对象创建############### -->
    
    <!-- 1. 默认无参数构造器 
    <bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
    -->
    
    <!-- 2. 带参数构造器 -->
    <bean id="user2" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
    </bean>
    
    <!-- 定义一个字符串，值是"Jack" ;  String s = new String("jack")-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="Jacks"></constructor-arg>
    </bean>
    <bean id="user3" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
    </bean>
    
    
    <!-- 3. 工厂类创建对象 -->
    <!-- # 3.1 工厂类，实例方法 -->
    <!-- 先创建工厂 -->
    <bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
    <!-- 在创建user对象，用factory方的实例方法 -->
    <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
    
    
    <!-- # 3.2 工厂类： 静态方法 -->
    <!-- 
        class 指定的就是工厂类型
        factory-method  一定是工厂里面的“静态方法”
     -->
    <bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
    
</beans>      

3.2对象依赖关系

Spring中，如何给对象的属性赋值?  【DI, 依赖注入】

         1) 通过构造函数

         2) 通过set方法给属性注入值

         3) p名称空间

         4)自动装配(了解)

         5) 注解

1）(常用)Set方法注入值

<!-- dao instance -->

    <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
    <!-- service instance -->
    <bean id="userService" class="cn.itcast.c_property.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

    <!-- action instance -->
    <bean id="userAction" class="cn.itcast.c_property.UserAction">
        <property name="userService" ref="userService"></property>
   </bean>

2）内部bean

<!-- ##############内部bean############## -->
    <bean id="userAction" class="cn.itcast.c_property.UserAction">
        <property name="userService">
            <bean class="cn.itcast.c_property.UserService">
                <property name="userDao">
                    <bean class="cn.itcast.c_property.UserDao"></bean>
                </property>
            </bean>
        </property>
    </bean>

3) p 名称空间注入属性值 (优化)

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- ###############对象属性赋值############### -->   

    <!--
        给对象属性注入值：
            # p 名称空间给对象的属性注入值
             (spring3.0以上版本才支持)
     -->
     <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
     <bean id="userService" class="cn.itcast.c_property.UserService" p:userDao-ref="userDao"></bean>
     <bean id="userAction" class="cn.itcast.c_property.UserAction" p:userService-ref="userService"></bean>

    <!-- 传统的注入：
     <bean id="user" class="cn.itcast.c_property.User" >
        <property name="name" value="xxx"></property>
     </bean>
    -->
    <!-- p名称空间优化后 -->
    <bean id="user" class="cn.itcast.c_property.User" p:name="Jack0001"></bean>
</beans>  

 4)自动装配(了解)

    ①根据名称自动装配：autowire="byName"

         ->自动去IOC容器中找与属性名同名的引用的对象，并自动注入

<!-- ###############自动装配############### --> 

    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>  

    <bean id="userService" class="cn.itcast.d_auto.UserService" autowire="byName"></bean>

    <!-- 根据“名称”自动装配： userAction注入的属性，会去ioc容器中自动查找与属性同名的对象 -->

    <bean id="userAction"

class="cn.itcast.d_auto.UserAction" autowire="byName"></bean>

也可以定义到全局， 这样就不用每个bean节点都去写autowire=”byName” 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byName">   根据名称自动装配（全局）

   

    <!-- ###############自动装配############### --> 

    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>  

    <bean id="userService" class="cn.itcast.d_auto.UserService"></bean>

    <bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>

</beans>  

②根据类型自动装配：autowire="byType"

必须确保改类型在IOC容器中只有一个对象；否则报错。

  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byType"> 
    <!-- ###############自动装配############### --> 
    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>  
    <bean id="userService" class="cn.itcast.d_auto.UserService"></bean>   
    <!-- 如果根据类型自动装配： 必须确保IOC容器中只有一个该类型的对象 -->
    <bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
    <!--   报错： 因为上面已经有一个该类型的对象，且使用了根据类型自动装配
    <bean id="userService_test" class="cn.itcast.d_auto.UserService" autowire="byType"></bean>
     -->
</beans> 

总结：

         Spring提供的自动装配主要是为了简化配置； 但是不利于后期的维护。

         (一般不推荐使用)

5）注解

注解方式可以简化spring的IOC容器的配置!

使用注解步骤：

         1）先引入context名称空间

                   xmlns:context="http://www.springframework.org/schema/context"

         2）开启注解扫描

                   <context:component-scan base-package="cn.itcast.e_anno2"></context:component-scan>

         3）使用注解

                   通过注解的方式，把对象加入ioc容器。

            创建对象以及处理对象依赖关系，相关的注解：

                   @Component   指定把一个对象加入IOC容器

　　　　　 @Repository   作用同@Component； 在持久层使用

                   @Service      作用同@Component； 在业务逻辑层使用

                   @Controller    作用同@Component； 在控制层使用

                   @Resource     属性注入

总结：

         1） 使用注解，可以简化配置，且可以把对象加入IOC容器,及处理依赖关系(DI)
         2） 注解可以和XML配置一起使用。

四、代理模式

4.1动态代理

动态代理

         1）代理对象，不需要实现接口；

         2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);

         3)  动态代理， JDK代理， 接口代理；

JDK中生成代理对象的API：

|-- Proxy

         static Object newProxyInstance(

　　　　ClassLoader loader,       指定当前目标对象使用类加载器

　　　    Class<?>[] interfaces,     目标对象实现的接口的类型

　　　　InvocationHandler h       事件处理器

　　) 

动态代理总结：

         代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！
         (class  $Proxy0  implements IuserDao)

思考：

         有一个目标对象，想要功能扩展，但目标对象没有实现接口，怎样功能扩展？

         Class  UserDao{}

         // 子类的方式

         Class subclass  extends  UserDao{}                                              

         以子类的方式实现(cglib代理)

4.2cglib代理

Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。

1)JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。

2)CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

3)CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

Cglib子类代理：

         1) 需要引入cglib – jar文件， 但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。

         2）引入功能包后，就可以在内存中动态构建子类

         3）代理的类不能为final， 否则报错。

         4） 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。

在Spring的AOP编程中，

         如果加入容器的目标对象有实现接口，用JDK代理；

         如果目标对象没有实现接口，用Cglib代理；

 五、手动实现AOP编程

AOP 面向切面的编程，

         AOP可以实现“业务代码”与“关注点代码”分离

思考：

关注点代码，就是指重复执行的代码。

         业务代码与关注点代码分离，好处？

            -->关注点代码写一次即可；

                   ->开发者只需要关注核心业务；

                   ->运行时期，执行核心业务代码时候动态植入关注点代码； 【代理】

如何分离？

         过程式/对象式/代理模式分离

5.1过程式

5.2对象式

5.3代理模式分离

六、AOP编程

6.1 概述

Aop，  aspect object programming  面向切面编程

         功能： 让关注点代码与业务代码分离！

关注点,

         重复代码就叫做关注点；

切面，

          关注点形成的类，就叫切面(类)！

          面向切面编程，就是指 对很多功能都有的重复的代码抽取，再在运行的时候网业务方法上动态植入“切面类代码”。

切入点，

         执行目标对象方法，动态植入切面代码。

         可以通过切入点表达式，指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码。

6.2注解方式实现AOP编程

步骤：

1） 先引入aop相关jar文件           （aspectj  aop优秀组件）                                      

       spring-aop-3.2.5.RELEASE.jar   【spring3.2源码】

　　aopalliance.jar                              【spring2.5源码/lib/aopalliance】

　　aspectjweaver.jar                         【spring2.5源码/lib/aspectj】或【aspectj-1.8.2lib】

　　aspectjrt.jar                                   【spring2.5源码/lib/aspectj】或【aspectj-1.8.2lib】 

注意： 用到spring2.5版本的jar文件，如果用jdk1.7可能会有问题。

            需要升级aspectj组件，即使用aspectj-1.8.2版本中提供jar文件提供。 

2） bean.xml中引入aop名称空间

 

3） 开启aop注解

 bean.xml中

4) 使用注解

@Aspect                                                              指定一个类为切面类（在类上写）             

@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")  指定切入点表达式， cn.itcast.e_aop_anno包下的所有类的所有方法（在方法上写）

@Pointcut("execution(* cn.itcast.e_aop_anno.UserDao.save(..))")拦截 cn.itcast.e_aop_anno包下的UserDao类中的save()方法，参数有两个，分别用点表示

@Before("pointCut_()")                                   前置通知: 目标方法之前执行

@After("pointCut_()")                                      后置通知：目标方法之后执行（始终执行）

@AfterReturning("pointCut_()")              返回后通知： 执行方法结束前执行（最后执行）(异常不执行)

@AfterThrowing("pointCut_()")                    异常通知:  目标方法出现异常时候执行（最后执行）

@Around("pointCut_()")                                  环绕通知： 环绕目标方法执行

 

输出结果

目标对象有实现接口，spring会自动选择“JDK代理”

目标对象没有实现接口， spring会用“cglib代理”

5）程序

     IUserDao.java

// 接口
public interface IUserDao {
    void save();
}

  UserDao.java

/**
 * 目标对象
 * @author Jie.Yuan
 *
 */
@Component   // 加入容器
public class UserDao implements IUserDao{
 
    @Override
    public void save() {
        System.out.println("-----核心业务：保存！！！------");
    }
}

 Aop.java  切面类

@Component
@Aspect  // 指定当前类为切面类
public class Aop {
 
    // 指定切入点表单式： 拦截哪些方法； 即为哪些类生成代理对象
   
    @Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")
    public void pointCut_(){
    }
   
    // 前置通知 : 在执行目标方法之前执行
    @Before("pointCut_()")
    public void begin(){
        System.out.println("开始事务/异常");
    }
     // 后置/最终通知：在执行目标方法之后执行  【无论是否出现异常最终都会执行】
    @After("pointCut_()")
    public void after(){
        System.out.println("提交事务/关闭");
    }
    // 返回后通知： 在调用目标方法结束后执行 【出现异常不执行】
    @AfterReturning("pointCut_()")
    public void afterReturning() {
        System.out.println("afterReturning()");
    }
    // 异常通知： 当目标方法执行异常时候执行此关注点代码
    @AfterThrowing("pointCut_()")
    public void afterThrowing(){
        System.out.println("afterThrowing()");
    }
    // 环绕通知：环绕目标方式执行
    @Around("pointCut_()")
    public void around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕前....");
        pjp.proceed();  // 执行目标方法
        System.out.println("环绕后....");
    }   
}

bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
   
    <!-- 开启注解扫描 -->
    <context:component-scan base-package="cn.itcast.e_aop_anno"></context:component-scan>
   
    <!-- 开启aop注解方式 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>  

6.3XML方式实现AOP编程

Xml实现aop编程：

         1） 引入jar文件  【aop 相关jar， 4个】

         2） 引入aop名称空间

         3）aop 配置

                   * 配置切面类 （重复执行代码形成的类）

                   * aop配置

                            拦截哪些方法 / 拦截到方法后应用通知代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- dao 实例 -->
    <bean id="userDao" class="cn.itcast.f_aop_xml.UserDao"></bean>
    <bean id="orderDao" class="cn.itcast.f_aop_xml.OrderDao"></bean>
    
    <!-- 切面类 -->
    <bean id="aop" class="cn.itcast.f_aop_xml.Aop"></bean>
    
    <!-- Aop配置 -->
    <aop:config>
        <!-- 定义一个切入点表达式： 拦截哪些方法 -->
        <aop:pointcut expression="execution(* cn.itcast.f_aop_xml.*.*(..))" id="pt"/>
        <!-- 切面 -->
        <aop:aspect ref="aop">
            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="pt"/>
            <!-- 前置通知： 在目标方法调用前执行 -->
            <aop:before method="begin" pointcut-ref="pt"/>
            <!-- 后置通知： -->
            <aop:after method="after" pointcut-ref="pt"/>
            <!-- 返回后通知 -->
            <aop:after-returning method="afterReturning" pointcut-ref="pt"/>
            <!-- 异常通知 -->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
            
        </aop:aspect>
    </aop:config>
</beans> 

6.4切入点表达式

切入点表达式,

         可以对指定的“方法”进行拦截；  从而给指定的方法所在的类生层代理对象。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- dao 实例 -->
    <bean id="userDao" class="cn.itcast.g_pointcut.UserDao"></bean>
    <bean id="orderDao" class="cn.itcast.g_pointcut.OrderDao"></bean>
    
    <!-- 切面类 -->
    <bean id="aop" class="cn.itcast.g_pointcut.Aop"></bean>
    
    <!-- Aop配置 -->
    <aop:config>
        
        <!-- 定义一个切入点表达式： 拦截哪些方法 -->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.*.*(..))" id="pt"/>-->
        
        <!-- 【拦截所有public方法】 -->
        <!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->
        
        <!-- 【拦截所有save开头的方法 】 -->
        <!--<aop:pointcut expression="execution(* save*(..))" id="pt"/>-->
        
        <!-- 【拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->
        <!--<aop:pointcut expression="execution(public * cn.itcast.g_pointcut.OrderDao.save(..))" id="pt"/>-->
        
        <!-- 【拦截指定类的所有方法】 -->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.*(..))" id="pt"/>-->
        
        <!-- 【拦截指定包，以及其自包下所有类的所有方法】 -->
        <!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->
        
        <!-- 【多个表达式】 -->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) || execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) or execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
        <!-- 下面2个且关系的，没有意义 -->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) &amp;&amp; execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) and execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
        
        <!-- 【取非值】 -->
        <!--<aop:pointcut expression="!execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
        <aop:pointcut expression=" not execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>
        
        <!-- 切面 -->
        <aop:aspect ref="aop">
            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="pt"/>
        </aop:aspect>
    </aop:config>
</beans>