java EE开发之spring第二章：spring中的AOP

一.Spring中的AOP

JDK动态代理:对实现了接口的类生成代理
CGLib代理机制:对类生成代理

1.spring传统aop
1.1.针对所有方法的增强:(不带有切点的切面)
第一步:导入相应jar包.
* spring-aop-3.2.0.RELEASE.jar
* com.springsource.org.aopalliance-1.0.0.jar

第二步:编写被代理对象:
* CustomerDao接口
* CustoemrDaoImpl实现类

第三步:编写增强的代码:

public class MyBeforeAdvice implements MethodBeforeAdvice{

    /**
     * method:执行的方法
     * args:参数
     * target:目标对象
     */
    public void before(Method method, Object[] args, Object target)
            throws Throwable {
        System.out.println("前置增强...");
    }
}

第四步:生成代理:(配置生成代理:)
  生成代理Spring基于ProxyFactoryBean类.底层自动选择使用JDK的动态代理还是CGLIB的代理.
属性:
target : 代理的目标对象
proxyInterfaces : 代理要实现的接口
如果多个接口可以使用以下格式赋值

<list>
    <value></value>
    ....
</list>

proxyTargetClass : 是否对类代理而不是接口，设置为true时，使用CGLib代理
interceptorNames : 需要织入目标的Advice
singleton : 返回代理是否为单实例，默认为单例
optimize : 当设置为true时，强制使用CGLib

<!-- 不带有切点的切面 -->
    <!-- 定义目标对象 -->
    <bean id="customerDao" class="com.kz.spring3.demo3.CustomerDaoImpl"></bean>

    <!-- 定义增强 -->
    <bean id="beforeAdvice" class="com.kz.spring3.demo3.MyBeforeAdvice"></bean>

    <!-- Spring支持配置生成代理: -->
    <bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 设置目标对象 -->
        <property name="target" ref="customerDao"/>
        <!-- 设置实现的接口 ,value中写接口的全路径 -->
        <property name="proxyInterfaces" value="com.kz.spring3.demo3.CustomerDao"/>
        <!-- 需要使用value:要的名称 -->
        <property name="interceptorNames" value="beforeAdvice"/>
        <!-- 强制使用CGLIB代理 -->
        <property name="optimize" value="true"></property>
    </bean>

* 注入的时候要注入代理对象:

@Autowired
// @Qualifier("customerDao")// 注入是真实的对象,必须注入代理对象.
@Qualifier("customerDaoProxy")
private CustomerDao customerDao;

1.2.带有切点的切面:(针对目标对象的某些方法进行增强)

PointcutAdvisor 接口:
DefaultPointcutAdvisor 最常用的切面类型，它可以通过任意Pointcut和Advice 组合定义切面
RegexpMethodPointcutAdvisor 构造正则表达式切点切面

第一步:创建被代理对象.
* OrderDao

第二步:编写增强的类:
**public class MyAroundAdvice implements MethodInterceptor{

public Object invoke(MethodInvocation methodInvocation) throws Throwable {
    System.out.println("环绕前增强...");
    Object result = methodInvocation.proceed();// 执行目标对象的方法
    System.out.println("环绕后增强...");
    return result;
}

}**

第三步:生成代理:

<!-- 带有切点的切面 -->
    <!-- 定义目标对象 -->
    <bean id="orderDao" class="com.kz.spring3.demo4.OrderDao"></bean>

    <!-- 定义增强 -->
    <bean id="aroundAdvice" class="com.kz.spring3.demo4.MyAroundAdvice"></bean>
    <!-- 定义切点切面: -->
    <bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <!-- 定义表达式,规定哪些方法执行拦截 -->
        <!-- . 任意字符  * 任意个 -->
        <!-- <property name="pattern" value=".*"/> -->
        <!-- <property name="pattern" value="cn\.kz\.spring3\.demo4\.OrderDao\.add.*"/> -->
        <!-- <property name="pattern" value=".*add.*"></property> -->
        <property name="patterns" value=".*add.*,.*find.*"></property>
        <!-- 应用增强 -->
        <property name="advice" ref="aroundAdvice"/>
    </bean>
<!-- 定义生成代理对象 -->
    <bean id="orderDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 配置目标 -->
        <property name="target" ref="orderDao"></property>
        <!-- 针对类的代理 -->
        <property name="proxyTargetClass" value="true"></property>
        <!-- 在目标上应用增强 -->
        <property name="interceptorNames" value="myPointcutAdvisor"></property>
    </bean>

2.自动代理:

  前面的案例中，每个代理都是通过ProxyFactoryBean织入切面代理，在实际开发中，非常多的Bean每个都配置ProxyFactoryBean开发维护量巨大

自动创建代理(*基于后处理Bean就是在Bean创建的过程中完成的增强.生成Bean就是代理.)
BeanNameAutoProxyCreator 根据Bean名称创建代理
DefaultAdvisorAutoProxyCreator 根据Advisor本身包含信息创建代理

• AnnotationAwareAspectJAutoProxyCreator 基于Bean中的AspectJ 注解进行自动代理

2.1.BeanNameAutoProxyCreator :按名称生成代理

<!-- 定义目标对象 -->
    <bean id="customerDao" class="com.kz.spring3.demo3.CustomerDaoImpl"></bean>
    <bean id="orderDao" class="com.kz.spring3.demo4.OrderDao"></bean>

    <!-- 定义增强 -->
    <bean id="beforeAdvice" class="com.kz.spring3.demo3.MyBeforeAdvice"></bean>
    <bean id="aroundAdvice" class="com.kz.spring3.demo4.MyAroundAdvice"></bean>

    <!-- 自动代理:按名称的代理 基于后处理Bean,后处理Bean不需要配置ID-->
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="beanNames" value="*Dao"/>
        <property name="interceptorNames" value="beforeAdvice"/>
    </bean>

2.2.DefaultAdvisorAutoProxyCreator :根据切面中定义的信息生成代理

<!-- 定义目标对象 -->
    <bean id="customerDao" class="com.kz.spring3.demo3.CustomerDaoImpl"></bean>
    <bean id="orderDao" class="com.kz.spring3.demo4.OrderDao"></bean>

    <!-- 定义增强 -->
    <bean id="beforeAdvice" class="com.kz.spring3.demo3.MyBeforeAdvice"></bean>
    <bean id="aroundAdvice" class="com.kz.spring3.demo4.MyAroundAdvice"></bean>

    <!-- 定义一个带有切点的切面 -->
    <bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="pattern" value=".*add.*"/>
        <property name="advice" ref="aroundAdvice"/>
    </bean>

    <!-- 自动生成代理 -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>

区分基于ProxyFattoryBean的代理与自动代理区别?
* ProxyFactoryBean:先有被代理对象,将被代理对象传入到代理类中生成代理.
自动代理基于后处理Bean.在Bean的生成过程中,就产生了代理对象,把代理对象返回.生成Bean已经是代理对象.

3.spring的aspectJ的aop

  AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。
  AspectJ是一个基于Java语言的AOP框架，Spring2.0以后新增了对AspectJ切点表达式支持@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面新版本Spring框架，建议使用AspectJ方式来开发AOP。
AspectJ表达式:
* 语法:execution(表达式)
execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

• execution(“* com.kz.spring3.demo1.dao.*(..)”) —只检索当前包
• execution(“* com.kz.spring3.demo1.dao..*(..)”) —检索包及当前包的子包.
• execution(* com.kz.dao.GenericDAO+.*(..)) —检索GenericDAO及子类

AspectJ增强:
@Before 前置通知，相当于BeforeAdvice
@AfterReturning 后置通知，相当于AfterReturningAdvice
@Around 环绕通知，相当于MethodInterceptor
@AfterThrowing抛出通知，相当于ThrowAdvice
@After 最终final通知，不管是否异常，该通知都会执行
@DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)

（1）.基于XML:
第一步:编写被增强的类:
* ProductDao

第二步:定义切面

第三步:配置applicationContext.xmll

前置通知:
* 代码:

    public void before(){
        System.out.println("前置通知...");
    }

• 配置:

<aop:config>
        <!-- 定义切点: -->
        <aop:pointcut expression="execution(* com.kz.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
        <aop:aspect ref="myAspectXML">
            <!-- 前置通知 -->
            <aop:before method="before" pointcut-ref="mypointcut"/>
        </aop:aspect>
    </aop:config>

后置通知:
* 代码:

    public void afterReturing(Object returnVal){
        System.out.println("后置通知...返回值:"+returnVal);
    }

• 配置:

    <aop:config>
        <!-- 定义切点: -->
        <aop:pointcut expression="execution(* com.kz.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
        <aop:aspect ref="myAspectXML">
            <!-- 后置通知 -->
            <aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/>
        </aop:aspect>
    </aop:config>

环绕通知:
* 代码:

    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕前增强....");
        Object result = proceedingJoinPoint.proceed();
        System.out.println("环绕后增强....");
        return result;
    }

• 配置:

<aop:config>
        <!-- 定义切点: -->
        <aop:pointcut expression="execution(* com.kz.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
        <aop:aspect ref="myAspectXML">
            <!-- 前置通知 -->
            <!-- <aop:before method="before" pointcut-ref="mypointcut"/> -->
            <!-- 后置通知 -->
            <!-- <aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/> -->
            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="mypointcut"/>
        </aop:aspect>
    </aop:config>

异常通知:
* 代码;

public void afterThrowing(Throwable e){
        System.out.println("异常通知..."+e.getMessage());
    }

• 配置;

<aop:config>
        <!-- 定义切点: -->
        <aop:pointcut expression="execution(* com.kz.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
        <aop:aspect ref="myAspectXML">
            <!-- 异常通知 -->
            <aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut" throwing="e"/>
        </aop:aspect>
    </aop:config>

最终通知:
* 代码:

    public void after(){
        System.out.println("最终通知....");
    }

• 配置:

<aop:config>
        <!-- 定义切点: -->
        <aop:pointcut expression="execution(* com.kz.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
        <aop:aspect ref="myAspectXML">
            <!-- 最终通知 -->
            <aop:after method="after" pointcut-ref="mypointcut"/>
        </aop:aspect>
    </aop:config>

（2）.基于注解:

第一步:引入相应jar包.
* aspectj依赖aop环境.
* spring-aspects-3.2.0.RELEASE.jar
* com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

第二步:编写被增强的类:
* UserDao

第三步:使用AspectJ注解形式:
@Aspect

public class MyAspect {

    @Before("execution(* com.kz.spring3.demo1.UserDao.add(..))")
    public void before(){
        System.out.println("前置增强....");
    }

}

第四步:创建applicationContext.xml

* 引入aop的约束:
* <aop:aspectj-autoproxy /> --- 自动生成代理:
* 底层就是AnnotationAwareAspectJAutoProxyCreator

    <aop:aspectj-autoproxy />
    <bean id="userDao" class="com.kz.spring3.demo1.UserDao"></bean>
    <bean id="myAspect" class="com.kz.spring3.demo1.MyAspect"></bean>

AspectJ的通知类型:

@Before 前置通知，相当于BeforeAdvice
* 就在方法之前执行.没有办法阻止目标方法执行的.
@AfterReturning 后置通知，相当于AfterReturningAdvice
* 后置通知,获得方法返回值.
@Around 环绕通知，相当于MethodInterceptor
* 在可以方法之前和之后来执行的,而且可以阻止目标方法的执行.
@AfterThrowing抛出通知，相当于ThrowAdvice
@After 最终final通知，不管是否异常，该通知都会执行
@DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)

切点的定义:

@Pointcut(“execution(* com.kz.spring3.demo1.UserDao.find(..))”)
private void myPointcut(){}

面试:
* Advisor和Aspect的区别?
* Advisor:Spring传统意义上的切面:支持一个切点和一个通知的组合.
* Aspect:可以支持多个切点和多个通知的组合.

二.Spring的JdbcTemplate

  JdbcTemplate模板与DbUtils工具类比较类似，2.4.1.Spring对持久层技术支持:
JDBC : org.springframework.jdbc.core.JdbcTemplate
Hibernate3.0 : org.springframework.orm.hibernate3.HibernateTemplate
IBatis(MyBatis) : org.springframework.orm.ibatis.SqlMapClientTemplate
JPA : org.springframework.orm.jpa.JpaTemplate

1.开发JDBCTemplate入门:

第一步:引入相应jar包:
* spring-tx-3.2.0.RELEASE.jar
* spring-jdbc-3.2.0.RELEASE.jar
* mysql驱动.

第二步:创建applicationContext.xml

第三步:编写一个测试类:

2.配置连接池:
2.1.Spring默认的连接池:

<bean id="dataSource" 
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring3_day02"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean>

2.2.DBCP连接池:
导入jar包:

com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar
com.springsource.org.apache.commons.pool-1.5.3.jar

<!-- 配置DBCP连接池 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring3_day02"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean>

2.3.C3P0连接池:
导入jar包:

com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar

<!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql:///spring3_day02"/>
<property name="user" value="root"/>
<property name="password" value="123"/>
</bean>

2.4.参数设置到属性文件中:
在src下创建jdbc.properties

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql:///spring3_day02
jdbc.user = root
jdbc.password = 123

需要在applicationContext.xml 中使用属性文件配置的内容.
* 第一种写法:

<bean class="org.springframework.beans.factory.config.
                                        PropertyPlaceholderConfigurer">
<propertyname="location" value="classpath:jdbc.properties">
</property>
</bean>

• 第二种写法:

<context:property-placeholder location="classpath:jdbc.properties"/>

2.5.JdbcTemplate的CRUD的操作:

Spring框架中提供了对持久层技术支持的类:
JDBC : org.springframework.jdbc.core.support.JdbcDaoSupport
Hibernate 3.0 : org.springframework.orm.hibernate3.support.HibernateDaoSupport
iBatis : org.springframework.orm.ibatis.support.SqlMapClientDaoSupport

第1步：编写DAO的时候:
Public class UserDao extends JdbcDaoSupport{

}

第2步：进行CRUD的操作;
* 保存:update(String sql,Object… args)
* 修改:update(String sql,Object… args)
* 删除:update(String sql,Object… args)

第3步：查询:
* 简单查询:

select count(*) from user;          --- queryForInt(String sql);
 select name from user where id = ?;    
        --- queryForObject(String sql,Class clazz,Object... args);

• 复杂查询:(返回对象,和对象集合)

 select * from user where id = ?        
        --- queryForObjectString sql,RowMapper<T> rowMapper,Object... args);
select * from user;                 
    --- query(String sql,RowMapper<T> rowMapper,Object... args);