aop入门前内容：静态代理

在学习aop之前，为了更好，更全面的理解aop打好基础。我们先要复习一下代理模式，首先我们来谈一下静态代理。
我们拿hibernate的一个小例子：
在保存学生的时候，经常使用到这样的语句:

//开启事务
Transation transation=session.beginTransation();
//操作
session.update()/save()/delete();

//提交事务
transation.commit();

session.close();

通过上面的观察我们可以看到，hibernate操作数据库中的开启关闭事务都是固定的语句，但是每次的操作不一样。然后aop的目的就是把”变化”的语句跟”固定”分离开来。如下图所示：

静态代理的小例子

代理类跟目标类实现同样的接口，并且代理类里面有目标类的引用
我们用保存Person来做例子：

//接口：
public interface PersonDAO {
    public void savePerson();
    public void deletePerson();
    public void updatePerson();

}


//这个相当于目标类
public class PersonDAOImpl implements PersonDAO {

    @Override
    public void deletePerson() {
        System.out.println("delete person");
    }

    @Override
    public void savePerson() {
        System.out.println("save person");
    }

    @Override
    public void updatePerson() {
        System.out.println("update person");
    }

}

//处理事务的类
public class transation {
    //开启事务
    public void beginTransation(){
        System.out.println("begin transation");
    }
    //提交事务
    public void commit(){
        System.out.println("commit transation");
    }
}


//代理类
public class PersonDAOProxy implements PersonDAO {
    //首先要有目标类的引用
    private PersonDAO daoImpl;
    //由于要与事务分离开 所以另外在一个类
    private transation transation;

    public PersonDAOProxy(PersonDAO daoImpl, transation transation) {
        this.daoImpl = daoImpl;
        this.transation = transation;
    }

    @Override
    public void deletePerson() {
        transation.beginTransation();
        daoImpl.deletePerson();
        transation.commit();
    }

    @Override
    public void savePerson() {
        transation.beginTransation();
        daoImpl.savePerson();
        transation.commit();
    }

    @Override
    public void updatePerson() {
        transation.beginTransation();
        daoImpl.updatePerson();
        transation.commit();
    }

}

配置文件：
  <!-- 
        在配置文件中把目标类，代理类还有事务类，放进sprig容器中。
        并利用构造函数的方法为代理类的构造函数中的属性赋值
      -->
    <bean id="personDAOImpl" class="cn.ansel.proxy.spring.PersonDAOImpl"></bean>
    <bean id="personDAOProxy" class="cn.ansel.proxy.spring.PersonDAOProxy">
        <constructor-arg index="0" ref="personDAOImpl"></constructor-arg>
        <constructor-arg index="1" ref="transation"></constructor-arg>
    </bean>
    <bean id="transation" class="cn.ansel.proxy.spring.transation"></bean>



//测试类
public class proxyTest {
    @Test
    public void testProxy(){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("cn/ansel/proxy/spring/applicationContext-proxy.xml");
        PersonDAO dao=(PersonDAO) applicationContext.getBean("personDAOProxy");
        dao.savePerson();
    }
}

运行结果：

小结及缺点分析：

从上面的代码我们可以看到，使用静态代理方法，还是有很多重复的代码，即所谓的代码的复用性不高，因为每次操作，都要开启/提交事务，非常麻烦，而且代码都是重复的。再者没运行一次，都要把对象new一次。