使用java实现工厂模式和代理模式

• 工厂模式
  通过IO流读取配置文件的方式创建bean，然后通过反射获取类对象。配置文件应该提供类的全限定名。

package net.test.factory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

import net.wanho.config.DataCode;
import net.wanho.proxy.TransactionProxy;

/**
 * <工厂类>
 * 
 * @author zj
 * @version [V1.0.0,2017-4-10]
 * 
 */
public class BasicFactory {

    private static Map<String, Object> objects = new HashMap<String, Object>();
    static {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(BasicFactory.class
                    .getClassLoader().getResourceAsStream("beans.properties")));
            String s = null;
            while ((s = br.readLine()) != null) {
                if(!"".equals(s) && !"#".equals(s.charAt(0))){
                    String[] entry = s.split("=");
                    //通过model的无参构造方法创建对象
                    objects.put(entry[0], Class.forName(entry[1]).newInstance());
                }else{
                    continue;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ExceptionInInitializerError(DataCode.SYS_9007);
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static Object getObject(String key) {
        final Object obj = objects.get(key);
        //在这里指定事务处理的代码，通过java动态代理实现，必须基于接口
        if (key.contains("service") || key.contains("Service")) {
            return TransactionProxy.createProxy(obj);
        }else{
            return obj;
        }
    }
}

---

• 代理模式—–通过代理模式实现事务处理

• 1、创建接口，提供事务处理的方法

package net.test.transaction;

import net.wanho.exception.ServiceException;

/**
 * 事务管理接口
 *
 */
public interface TransManagerI {
    //开启事务
    void beginTrans() throws ServiceException;

    //提交事务
    void commitTrans() throws ServiceException;

    //回滚事务
    void rollbackTrans() throws ServiceException;

    //释放连接
    void releaseConnection() throws ServiceException;
}

• 2、实现目标对象

package net.test.transaction.impl;

import java.sql.Connection;
import java.sql.SQLException;

import net.test.config.DataCode;
import net.test.exception.ServiceException;
import net.test.transaction.TransManagerI;
import net.test.util.JDBCUtil;

/**
 * 事务管理的实现类
 *
 */
public class TransManagerImpl implements TransManagerI {

    @Override
    public void beginTrans() throws ServiceException {
        try {
            Connection con = JDBCUtil.getConnection();
            con.setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new ServiceException(DataCode.SYS_9004);
        }
    }

    @Override
    public void commitTrans() throws ServiceException {
        Connection con = null;
        try {
            con = JDBCUtil.getConnection();
            con.commit();
            con.setAutoCommit(true);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new ServiceException(DataCode.SYS_9005);
        } finally {
            JDBCUtil.close(con, null, null);
        }
    }

    @Override
    public void rollbackTrans() throws ServiceException {
        Connection con = null;
        try {
            con = JDBCUtil.getConnection();
            con.rollback();
            con.setAutoCommit(true);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new ServiceException(DataCode.SYS_9006);
        } finally {
            JDBCUtil.close(con, null, null);
        }
    }

    @Override
    public void releaseConnection() throws ServiceException {
        JDBCUtil.close();
    }

}

• 3、实现代理对象，通过Proxy代理对象实现代理。和spring中的jdk动态代理一样（必须实现接口）

package net.test.proxy;

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

import net.test.factory.BasicFactory;
import net.test.transaction.TransManagerI;

import org.omg.CORBA.TRANSACTION_MODE;


public class TransactionProxy {
    private static TransManagerI transManager = (TransManagerI) BasicFactory.getObject("iTransaction");
    // 被代理类

    public static Object createProxy(final Object target) {

        // 通过JDK创建的动态代理
        Object proxyObject = Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object res = null;
                        // 查询不加事务
                            try {
                                transManager.beginTrans();
                                res = method.invoke(target, args);
                                transManager.commitTrans();
                                //关闭Connection
                                transManager.releaseConnection();
                            } catch (Exception e) {
                                e.printStackTrace();
                                transManager.rollbackTrans();
                            }

                        return res;
                    }
                });
        return proxyObject;
    }

}