spring中用动态代理使业务层和事务控制分离

 

/**
 * 模拟一个消费者
 */

        /**
         * 动态代理：
         *  特点：字节码随用随创建，随用随加载
         *  作用：不修改源码的基础上对方法增强
         *  分类：
         *      基于接口的动态代理
         *      基于子类的动态代理
         *  基于接口的动态代理：
         *      涉及的类：Proxy
         *      提供者：JDK官方
         *  如何创建代理对象：
         *      使用Proxy类中的newProxyInstance方法
         *  创建代理对象的要求：
         *      被代理类最少实现一个接口，如果没有则不能使用
         *  newProxyInstance方法的参数：
         *      ClassLoader：类加载器
         *          它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
         *      Class[]：字节码数组
         *          它是用于让代理对象和被代理对象有相同方法。固定写法。
         *      InvocationHandler：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。
         */
  

package com.xp.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//基于接口的动态代理
public class Client {



    public static void main(String[] args) {

        final Producer producer = new ProducerImpl();

         Producer proxyProducer = (Producer) Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 作用：执行被代理对象的任何接口方法都会经过该方法
                     * 方法参数的含义
                     * @param proxy   代理对象的引用
                     * @param method  当前执行的方法
                     * @param args    当前执行方法所需的参数
                     * @return        和被代理对象方法有相同的返回值
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        Object returnValue = null;
                        Float money = (Float) args[0];
                        if ("saleProduct".equals(method.getName())){
                            returnValue = method.invoke(producer, money*0.8f);
                        }

                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(1000f);
    }

}

 

 

基于子类的动态代理

/**
         * 动态代理：
         *  特点：字节码随用随创建，随用随加载
         *  作用：不修改源码的基础上对方法增强
         *  分类：
         *      基于接口的动态代理
         *      基于子类的动态代理
         *  基于子类的动态代理：
         *      涉及的类：Enhancer
         *      提供者：第三方cglib库！
         *  如何创建代理对象：
         *      使用Enhancer类中的create方法
         *  创建代理对象的要求：
         *      被代理类不能是最终类
         *  create方法的参数：
         *      Class：字节码
         *          它是用于指定被代理对象的字节码。
         *
         *      Callback：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。
         *          我们一般写的都是该接口的子接口实现类：MethodInterceptor
         */
     

package com.xp.proxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
// 基于子类的动态代理
public class Client2 {

    public static void main(String[] args) {

        final Producer producer = new ProducerImpl();

        Producer proxyProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object returnValue = null;
                Float money = (Float) objects[0];
                if ("repairProduct".equals(method.getName())){
                    returnValue = method.invoke(producer, money*0.8f);
                }

                return returnValue;
            }
        });
        proxyProducer.repairProduct(13800f);


    }

}

 

 

实操

使用动态代理实现事务控制：

本例通过配置xml注入方式实现

类：BeanFactory

2个局部属性 业务层接口，事务管理器

private IAccountService accountService;
private TransActionManager transActionManager;

并为其分别添加set方法，使spring自动注入.

编写方法获取业务层对象，使得每个业务层方法的调用都要经过此方法，从而实现对方法的事务控制。

本例使用基于接口的动态代理

public IAccountService getAccountService(){

return (业务层接口类) Proxy.newProxyInstance( 定义的接口对象.getClass().getClassLoader(),
        定义的接口对象.getClass().getInterfaces(),

                

    new InvocationHandler() {
       @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object retunValue = null;//定义返回值

            try {
               //1.开启事务,关闭自动提交
               transActionManager.beginTransaction();
               //2.执行操作
               retunValue = method.invoke(accountService, args);

               //3.提交
               transActionManager.commit();
               //4.返回结果
               return retunValue;
           } catch (Exception e) {
               //5.回滚
               transActionManager.rollback();
               e.printStackTrace();
           } finally {
               //6.释放连接
               transActionManager.release();
           }
             return null;
        }
     });

}

 

 

bean.xml:

<!-- 配置代理的service -->   通过调用service工厂的方法来获取service实力对象
<bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>

<!-- 配置beanfactory -->   service工厂
<bean id="beanFactory" class="com.xp.factory.BeanFactory">
    <property name="accountService" ref="accountService"></property>
    <property name="transActionManager" ref="transactionManager"></property>
</bean>

<!-- 配置Service -->    不再需要注入事务控制
<bean id="accountService" class="com.xp.service.impl.AccountServiceImpl">
    <!-- 注入dao -->
    <property name="accountDao" ref="accountDao"></property>

</bean>