Advice只有切面化之后才能显现出AOP的巨大优势

上一篇所讲到的Advice，经过ProxyFactoryBean织入到Bean中，实际上是织入到Bean的联接点上，这显然不是我们想看到的，因为并不是所有方法都需要同样的公用代码。spring提供了切点(Pointcut)的概念，指真正需要织入Advice的联接点，并且提供了专门的类org.springframework.aop.support.NameMatchMethodPointcutAdvisor把Advice和Pointcut结合成一个整体，叫切面(Advisor)，这样对Bean的方法就可以有选择的进行处理。因此，Advice只有切面化之后才能显现出AOP的巨大优势。

 

比如，我们对Dao类进行添加事务的处理，显然只有增，删，改才需要，而查询方法就不再需要。

Dao类：

public class StudentDaoImpl implements StudentDao {

  @Override
  public void delete(Integer id) {//事务处理已经被提取出去了
    Student stu=getStudentById(id);
    Session session=HibernateUtil.getCurrentSession();
    session.delete(stu);
  }

  @Override
  public Student getStudentById(Integer id) {//查询不需要事务
    Session session=HibernateUtil.openSession();
    Student stu=(Student)session.get(Student.class, id);
    return stu;
  }

  @SuppressWarnings("unchecked")
  @Override
  public List<Student> getStudents() {//查询不需要事务
    Session session=HibernateUtil.openSession();
    String hql="from Student";
    List<Student> stus=session.createQuery(hql).list();
    return stus;
  }

  @Override
  public void insert(Student stu) {//事务处理已经被提取出去了
    Session session=HibernateUtil.getCurrentSession();
    session.save(stu);
  }

  @Override
  public void modify(Student stu) {//事务处理已经被提取出去了
    Session session=HibernateUtil.getCurrentSession();
    session.saveOrUpdate(stu);
  }
}

 

Advice：

public class TransactionAdvice implements MethodInterceptor {
  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable {
    try{
    Session session=HibernateUtil.getCurrentSession();
    Transaction trans=session.beginTransaction();
    trans.begin();
    System.out.println("====begin transaction====");
    Object ret=invocation.proceed();
    trans.commit();
    System.out.println("====commit transaction====");
    return ret;
    }catch(Exception e){
      HibernateUtil.getCurrentSession().getTransaction().rollback() ;
      System.out.println( "**** rollback transaction ****") ;
      throw e ;
    }
  }
}

 

配置文件：

<beans>
  <bean id="targetDao" class="com.yangfei.spring.advisor.dao.StudentDaoImpl"></bean>
  <bean id="transAdvice" class="com.yangfei.spring.advisor.advice.TransactionAdvice"></bean>
  <bean id="transAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
    <property name="advice">
      <ref local="transAdvice"/>
    </property>
    <property name="mappedNames">
      <list>
        <value>insert</value>
        <value>delete</value>
        <value>modify</value>
      </list>
    </property>
  </bean>
  <bean id="dao" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="target">
      <ref bean="targetDao"/>
    </property>
    <property name="interceptorNames">
      <list>
        <value>transAdvisor</value>
      </list>
    </property>
      <property name="interfaces">
    <list>
      <value>com.yangfei.spring.advisor.dao.StudentDao</value>
    </list>
  </property>
  </bean>
</beans>

 

测试：

  public static void main(String[] args) {
    ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
    StudentDao dao=(StudentDao)ctx.getBean("dao");
    //查
    Student stu=dao.getStudentById(2);
    System.out.println(stu);
    
    List<Student> stus=dao.getStudents();
    for(Student s:stus){
      System.out.println(s);
    }
    /*
    dao.delete(4);
    
    Student s=new Student();
    s.setName("wangwu");
    s.setBirthday(new Date());
    dao.insert(s);*/
    
    Student s=new Student();
    s.setId(4);
    s.setName("zhaoliu");
    s.setBirthday(new Date());
    dao.modify(s);

 

运行结果：

Hibernate: select student0_.id as id0_0_, student0_.name as name0_0_, student0_.birthday as birthday0_0_ from spring_student student0_ where student0_.id=?
Student: zhangsan
Hibernate: select student0_.id as id0_, student0_.name as name0_, student0_.birthday as birthday0_ from spring_student student0_
Student: yangfei
Student: zhangsan
Student: lisi
Student: zhaoliu
====begin transaction====
Hibernate: select student0_.id as id0_0_, student0_.name as name0_0_, student0_.birthday as birthday0_0_ from spring_student student0_ where student0_.id=?
Hibernate: delete from spring_student where id=?
====commit transaction====
====begin transaction====
Hibernate: select max(id) from spring_student
Hibernate: insert into spring_student (name, birthday, id) values (?, ?, ?)
====commit transaction====
====begin transaction====
Hibernate: update spring_student set name=?, birthday=? where id=?
====commit transaction====

 

不过这里有个问题，ProxyFactoryBean一次只能给一个Bean织入切面，如果我们Bean要足够多的话，显然会把配置文件搞的非常庞大。幸运的是spring还提供了另一个类org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator，可以一次给多个Bean配置多个Advisor。当然，在使用Bean时，就不能直接用它BeanNameAutoProxyCreator的id了，而只能使用Bean各自的id，取出来的就是代理对象了。

<beans>
  <bean id="targetDao" class="com.yangfei.spring.advisor.dao.StudentDaoImpl"></bean>
  <bean id="targetDao2" class="com.yangfei.spring.advisor.dao.StudentDaoImpl"></bean>
  <bean id="transAdvice" class="com.yangfei.spring.advisor.advice.TransactionAdvice"></bean>
  <bean id="transAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
    <property name="advice">
      <ref local="transAdvice"/>
    </property>
    <property name="mappedNames">
      <list>
        <value>insert</value>
        <value>delete</value>
        <value>modify</value>
      </list>
    </property>
  </bean>
  <bean id="test" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

    <property name="interceptorNames">
      <list>
        <value>transAdvisor</value>
      </list>
    </property>
    <property name="beanNames">
      <list>
        <value>targetDao</value>
        <value>targetDao2</value>
      </list>
    </property>
  </bean>
</beans>