面向切面编程开发事务

一.面向切面编程开发事务
　　为了解决重复的代码,提出了面向切面编程开发的概念,
　　所谓的面向切面的开发就是针对指定的方法,可以在该方法执行之前或者之后织入一些辅助性得到代码

1.开发出一个事务的注解

//指定注解的使用范围 (只能在方法上使用)
@Target(ElementType.METHOD)
//定义注解的声明周期 (运行时有效)
@Retention(RetentionPolicy.RUNTIME)
public @interface Transactional {
}

2.调整业务层实现类 : 加上自己开发的注解
　　如果有 "@Transactional" 则进行事务处理,否则就不处理

public class EmpServiceImpl implements IEmpService {
    //需要调用数据层的方法所以需要确定数据层的实现类对象
    private IEmpDAO empDAO = new EmpDAOImpl();
    
    @Override
    @Transactional
    public boolean addEmp(Emp vo) throws Exception {
            return this.empDAO.insert(vo)>0;
    }
    @Override
    @Transactional
    public boolean removeEmpById(Integer id)  throws Exception {
            return this.empDAO.deleteById(id)>0;
    }
    @Override
    @Transactional
    public boolean editEmp(Emp vo) throws Exception  {
            return this.empDAO.update(vo)>0;
    }
    @Override
    @Transactional
    public Emp findEmpById(Integer id) throws Exception  {
            return this.empDAO.selectById(id);
    }
    @Override
    @Transactional
    public Map<String, Object> findAllSplit(String kw, Integer cp, Integer ls) throws Exception  {
        Map<String,Object> map = new HashMap<String, Object>();
            map.put("emplist",this.empDAO.selectSplitAll("%"+kw+"%", cp, ls));
            //统计数据量
            int number = this.empDAO.selectCount(kw);
            //计算出总的页数
            //int allPages = number/ls+number%ls==0?0:1;
            //int allPages = (int)Math.ceil(number/(double)ls));
            map.put("count",number);
            map.put("allPages",(int)Math.ceil(number/(double)ls));
            map.put("kw",kw);
            map.put("cp",cp);
            map.put("ls",ls);
            return map;
    }
    @Override
    @Transactional
    public boolean removeBacth(List<Object> ids) throws Exception  {
            return this.empDAO.deleteBatch(ids)>0;
    }
}

3.定义动态代理类

public class ServiceProxy implements InvocationHandler {
    private Object obj; // 真实主题类对象
    private Connection conn;

    public ServiceProxy() {
    }
    public ServiceProxy(Object obj) {
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 保存方法的返回值
        Object result = null;
        // 取得业务层实现类对象 (被代理的对象) 正在被执行的方法
        Method m = this.obj.getClass().getMethod(method.getName(), method.getParameterTypes());
        // 读取正在执行的方法上的注解
        Transactional transactional = m.getDeclaredAnnotation(Transactional.class);
        System.out.println("注解信息是: " + transactional);
        // 取得连接
        if (conn == null) 
            conn = DBUitl.getConnection();
            System.out.println("取得连接: " + conn);
            // 取得真实主体类对象 (就是业务层的实现类对象) 的反射对象
            Class<?> cls = this.obj.getClass();
        
        if (transactional == null) {
            System.out.println("没有事务处理");
            // 取得真实主题类对象中的所有属性 (业务层实现类对象中的 dao 层的实现类对象)
            for (Field fdao : cls.getDeclaredFields()) {
                // 取消属性的封装
                fdao.setAccessible(true);
                // 取得属性的值
                Object daoObj = fdao.get(this.obj);
                // 取得业务层实现类中的 dao 层实现类的 conn 属性 (目的是为了其赋值)
                Field fconn = daoObj.getClass().getDeclaredField("conn");
                fconn.setAccessible(true);
                // 为业务层实现类中的 dao层的实现类对象的 conn 赋值
                fconn.set(daoObj, conn);
            }
            // 执行方法
            result = method.invoke(this.obj, args);
            // 关闭连接
            DBUitl.close(conn);
        } else {
            System.out.println("有事务处理");
            try {
                // 取消事务的自动提交
                conn.setAutoCommit(false);
                // 取得真实主题类中的所有属性
                for (Field fdaoimpl : cls.getDeclaredFields()) {
                    // 取消属性的封装
                    fdaoimpl.setAccessible(true);
                    // 取得属性的值
                    Object fdao = fdaoimpl.get(this.obj);
                    // 取得业务层实现类中的 dao 层 实现类的 conn 属性
                    Field fconn = fdao.getClass().getDeclaredField("conn");
                    fconn.setAccessible(true);
                    // 为业务层实现类中的 dao 层实现类的 conn 属性赋值
                    fconn.set(fdao, conn);
                }
                // 执行方法
                result = method.invoke(this.obj, args);
                // 提交事务
                conn.commit();
            } catch (Exception e) {
                conn.rollback();
                e.printStackTrace();
            } finally {
                DBUitl.close(conn);
            }
        }
        System.out.println("关闭连接" + conn);
        return result;
    }
}

4.定义出工厂类

public class ServiceFactory {
    public static Object geiInstance(Class<?> cls) {
        try {
            //真实主体类对象
            Object obj = cls.newInstance();
            //取得代理类对象 
            InvocationHandler hander = new ServiceProxy(obj);
            //取得被代理之后的真实主题类对象
            Object proxyServiceObj = Proxy.newProxyInstance(hander.getClass().getClassLoader(), obj.getClass().getInterfaces(), hander);
            return proxyServiceObj;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

5.测试

public class Test {
    public static void main(String[] args) throws Exception {
        //取得真实主题对象
        IEmpService empService = (IEmpService)ServiceFactory.geiInstance(EmpServiceImpl.class);
        System.out.println(empService.findAllSplit("A", 1, 10));
    }
}