- 工厂模式
通过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;
}
}