近期学习了hibernate底层技术和spring 的底层技术，认为非常不错，所以想分享下，要是说的不够具体。能够去下载资源自己查看下载链接
技术的体现是在实际中的。如今大体介绍一下吧
首先介绍hibernate手动写：
仿HIBERNATE
hibernate是属于DAO,专门又来管理数据的，connection中还要考虑多线程的情况。同一个线程还要必需要是同样的connection对象。这就需要ThreadLocal来实
现。
1，connection考虑须要多线程，须要採用多例模式来实现，
2。读取配置文件，如真的hibernate中的配置文件（自己写的仅仅有mysqld的）
3，当须要进行事物处理的时，须要採用同一个connection对象。须要用到ThreadLocal对象进行设置
4。当connection关闭时，而不是直接关闭，仅仅是将其还回线程池中。
详细代码呈上：
<span style="font-size: 18px;">
/*
* 我们须要採用线程池避免线程冲突。多例模式----》获得时候须要上锁
* pool中的数量是有限的，我们採用了代理模式，改动 con.close(),将连接换回来
* 为了保证统一线程是一个用户，我们採用threadlocal本地线程技术
*/
public class hibernateFactory2 {
private static final int NUM=3;
private static List<Connection> pool =new ArrayList<Connection>();
</span><strong><span style="font-size:24px;color:#cc0000;"><u>private static ThreadLocal<Connection> t=new ThreadLocal<Connection>();//声明本地线程、</u></span></strong><span style="font-size: 18px;">
static{
</span><span style="color:#cc0000;font-size: 18px;"> <strong><u>//读取配置文件</u></strong>
Properties p =new Properties();
</span><span style="font-size: 18px;">
try {
p.load(hibernateFactory2.class.getClassLoader().getResourceAsStream("jdbc.properties"));
//读取里面的值，一直改动配置文件就可以
String driver=p.getProperty("driver");
String url=p.getProperty("url");
String user=p.getProperty("username");
String password=p.getProperty("password");
//System.out.println(driver+url+user+password);
Class.forName(driver);
for(int i=0;i<NUM;i++){
final Connection con=DriverManager.getConnection(url, user, password);
</span><span style="color:#cc0000;font-size: 18px;"><strong><em><u>//採用动态代理開始进行对connection接口实现代理，对con.close,实现换回去</u></em></strong>
Object o =Proxy.newProxyInstance(hibernateFactory2.class.getClassLoader(), new Class[]{Connection.class},
new InvocationHandler() { @Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if(method.getName().equals("close")){
pool.add((Connection)(proxy));
System.out.println("换回来了。。 。 ");
return null;
}
return method.invoke(con, args);
}
});
pool.add((Connection)o);</span><span style="font-size: 18px;">
}
// System.out.println("初始化完成"+con);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } public static synchronized Connection getCon() throws Exception{
/*
* <span style="color:#ff0000;"><strong><em>把自己主动会到一个它所维护的那个map中去取，把以“当前线程对象”为key所相应的那个value取出来</em></strong></span>
*/
Connection c=t.get();
if(c==null){
while(pool.size()<=0){
System.out.println("池中已经乜有连接");
Thread.sleep(1000);
}
c=pool.remove(0);//为事物处理方便了。当出现错误的时候，多表一个都不能存储。採用一个connection
t.set(c);
}
return c;
}
}
</span>
仿Spring
这一层基本上进行的是业务逻辑处理
1，刚開始时候，将事务处理写在这一层。可是对于单个的函数的。每个须要写。代码太繁琐了，所以直接将从servlet转到service的时候（切面技术），採用代理模式代理一下，在代理模式里面，我们採用进行事物处理，须要的我们拦截进行事物处理。不须要的。我们直接放行，做他自己的事情。
2，在使用代理模式的时候。为了让外面注入不须要强转。proxy里面採用了泛型的引入。
详细代码呈上：
public class Tx implements InvocationHandler{
private Object srcobj;
private Object returnValue;
public Tx(Object srcobj) {
this.srcobj=srcobj;
}
<span style="color:#cc0000;"><strong>//这里写的是通用版本号，代理模式</strong></span>
//这个须要强转。所以引入了以下的那个不须要强转
// public static Object getProxy(Object srcobj){
// Object o =Proxy.newProxyInstance(
// Tx.class.getClassLoader(),
// srcobj.getClass().getInterfaces(),
// new Tx(srcobj));
// return o;
// }
/*
*<strong> 以下这个是升级版本号，返回的类型不用强转</strong>
*/
public static<T> T getProxy(Object srcobj){
Object o =Proxy.newProxyInstance(
Tx.class.getClassLoader(),
srcobj.getClass().getInterfaces(),
new Tx(srcobj));
return (T)o;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//全部的代理在这里開始
Connection con=null;
<u><strong><span style="color:#ff0000;">if(method.isAnnotationPresent(MyTrans.class)){//这里採用注解的方式来差别是都须要进行事物处理</span></strong></u>
System.out.println("被拦截了");
try {
con =hibernateFactory2.getCon();
con.setAutoCommit(false);
returnValue=method.invoke(srcobj, args);//调用被代理的自己去运行
con.commit();
System.out.println("事物提交成功");
} catch (Exception e) {
try {
System.out.println("回滚了"+e.getMessage());
con.rollback();
}catch (SQLException e1) {
throw new RuntimeException("回滚失败"+e.getMessage());
}
}finally{
try {
con.setAutoCommit(true);
con.close();//这里关闭，是还回池中，採用代理模式改动过
}catch (SQLException e) {
throw new RuntimeException("关闭数据库连接失败11"+e.getMessage());
}
}
}else{
System.out.println("不拦截，放行！
。");
return method.invoke(srcobj, args);
}
return returnValue;
}
}
这是自己写的注解类
package cn.hncu.publs.tx; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; @Retention(RetentionPolicy.RUNTIME)//作用于执行时，默认在编译器
@Target(value=ElementType.METHOD)//作用于方法
public @interface MyTrans {
}
源码已上传下载链接
欢迎各位大神指点