2021-07-11基于动态代理的Spring事务管理

一、代理模式

1.特点

（1）使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。
（2）任何对原始对象的调用都要通过代理。
（3）代理对象决定是否以及何时将方法调用转到原始对象上。

2.作用

功能增强:在原有的功能上,增加额外的功能.
控制访问:代理类不让你访问目标,例如商家不让用户访问厂家

二、静态代理

1.缺点

（1）代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展.
（2）每一个代理类只能为一个接口服务，会产生过多的代理。

2.代码示例

//定义公共的接口
interface ClothFactory{

    void produceCloth();

}
//目标类
class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

//代理类
class ProxyClothFactory implements ClothFactory{

    private ClothFactory factory;//用被代理类对象进行实例化

    public ProxyClothFactory(ClothFactory factory){
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");

        factory.produceCloth();

        System.out.println("代理工厂做一些后续的收尾工作");

    }
}



public class StaticProxyTest {
    public static void main(String[] args) {
        //创建目标类的对象
        ClothFactory nike = new NikeClothFactory();
        //创建代理类的对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
		//通过代理类调用目标类的方法
        proxyClothFactory.produceCloth();

    }
}

三、动态代理（jdk）

1.特点

代理类对象在程序运行时由JVM根据反射机制动态生成的，jdk运行期间，动态创建class字节码并加载到JVM。

2.实现

通过反射包java.lang. reflect,里面的三个类：InvocationHandler（接口），Method，Proxy。

（1）InvocationHandler

一个接口 (调用处理器)，只含有一个方法，代理类要完成的功能就写在​ invoke（）方法中。

invoke方法体包括：

• 切面（增强）方法
• 通过method.invoke(obj,args)调用目标方法

（2）Method

执行某个目标类的方法：method. invoke(目标对象,方法的参数)。
例如:

//创建目标类对象
SuperMan superMan = new SuperMan();
//通过代理工厂创建代理类的对象
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
//当通过代理类对象调用目标对象的getBelief方法时，会自动的调用被代理类中（增强的）同名的方法。
String belief = proxyInstance.getBelief();//调用invoke（）方法。

（3）Proxy

使用proxy类的方法，代替new来创建代理对象。

Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler)

参数：目标对象的类加载器，目标对象实现的接口，handler实现类（内含invoke方法）

3.代码示例

要想实现动态代理，需要解决的问题？
问题一：如何根据加载到内存中的被代理类，动态的创建一个代理对象。
答：通过Proxy.newProxyInstance（）方法
问题二：当通过代理类的对象调用方法a时，如何动态的去调用目标类中的同名方法。
答：通过实现InvocationHandler接口，将目标类的方法写进invoke方法中。

interface Human{

    String getBelief();

    void eat(String food);

}
//目标类
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

class HumanUtil{//切面类

    public void method1(){
        System.out.println("====================通用方法一====================");

    }

    public void method2(){
        System.out.println("====================通用方法二====================");
    }

}



class ProxyFactory{
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj){//obj:被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();

        handler.bind(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }

}

class MyInvocationHandler implements InvocationHandler{

    private Object obj;//需要使用被代理类的对象进行赋值

    public void bind(Object obj){
        this.obj = obj;
    }

    //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        HumanUtil util = new HumanUtil();
        util.method1();

        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object returnValue = method.invoke(obj,args);

        util.method2();

        //上述方法的返回值就作为当前类中的invoke()的返回值。
        return returnValue;

    }
}

public class ProxyTest {

    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();//调用invoke（）方法。
        System.out.println(belief);
        proxyInstance.eat("四川麻辣烫");

        System.out.println("*****************************");

        NikeClothFactory nikeClothFactory = new NikeClothFactory();

        ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);

        proxyClothFactory.produceCloth();//调用invoke（）方法。

    }
}

四、Spring AOP

1.AOP相关概念

2. 开发注意事项

1.手动实现事务

例子：银行账户相关的服务，涉及转账等操作。

public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void transfer(String outMan, String inMan, double money) {
    //手动实现事务
    try{
        accountDao.out(outMan,money);//对应一个update的事务
        int i = 1/0;
        accountDao.in(inMan,money);//对应一个update的事务
        }catch(Exception e){
        	rollback();
        }
    }

缺点: 当类中有

2.spring基于xml的声明式事务控制

3.spring基于注解的声明式事务控制