Hibernate的入门篇(1)

Hibernate是什么?

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

对象关系映射框架

　　对象关系映射简称ORM(Object Relational Mapping),由于我们目前使用的编程语言大都是面向对象的编程,使用的数据库也大多都是关系型数据库,数据得以对象的形式在程序中使用,并且程序中的有些对象(数据对象)得永久保存在数据库中,故就出现了ORM,说得更通俗点:ORM就是将数据库中的数据和程序中的对象进行互相的转换!

　　如今的ORM框架可以说是很丰富的:

Hibernate，开源 ORM 框架，广泛使用(使用最广泛)
iBATIS，开源,由ASF维护，并且有 .NET移植(使用的也较广泛)
TopLink，由Oracle开发
Cayenne，Apache，java 开源
QuickDB ORM，开源 ORM 框架 (GNU LGPL)
Java Data Objects (JDO)
Java Persistence API (JPA)
JPOX，开源 JDO 2 参考实现
Object Relational Bridge (Apache OJB)，一个Java的对象关系映射器
OpenJPA，Apache，开源，支持 JPA API

　　上面举例说了那么多ORM,那么ORM和Hibernate是什么关系呢?

　　一句说:Hibernate是ORM框架的一种实现.

　　这里我不得不说一下,大家不要觉得框架是一个很神奇的东西,其实我们也一直在做,一直在用,只不过我们所用所做的框架使用的范围不够大(也就是没普遍性),而且没也给它一个官方的名字而已!

　　ORM我们平时有做吗?

　　做Java开发的人,也一直在做,也一直在用,最常用的的DAO模式,DAO也是ORM的一种实现!

　　一个典型的DAO实现有下列几个组件:

　　1. 一个DAO工厂类;(工厂设计模式)

　　2. 一个DAO接口;(定义数据库操作)

　　3. 一个实现DAO接口的具体类;

　　4. 数据传递对象(有些时候叫做值对象).

下面写一个具体的DAO的实现

　　DAO工厂类:

 1 package com.library.dao;
 2 
 3 public class DaoFactory
 4 {
 5 
 6     public static UserDAO getUserDAO()
 7     {
 8         return new UserImp();
 9     }
10     
11     public static BookDAO getBookDAO()
12     {
13         return new BookImp();
14     }
15     
16     public static LendDAO getLendDAO()
17     {
18         return new LendImp();
19     }
20 }

UserDAO接口类:

 1 package com.library.dao;
 2 
 3 import java.util.Vector;
 4 
 5 import com.library.bean.User;
 6 
 7 public interface UserDAO
 8 {
 9 
10     public User query(String username,String password);
11     
12     public boolean query(int stuid);
13     
14     public boolean query(String username);
15     
16     public int save(User user);
17     
18     public int update(int id,User user);
19     
20     public int getCount();                           //返回所有的行数
21     
22     public Vector<Vector<Object>> query();                   //查询所有
23     
24     public int delete(int id);                            //管理员根据id删除用户
25     
26     public String getUserName(int user_id);              //根据用户编号得到用户名
27 }

UserImp实现UserDAO接口类:

  1 package com.library.dao;
  2 
  3 import java.sql.PreparedStatement;
  4 import java.sql.ResultSet;
  5 import java.sql.SQLException;
  6 import java.util.Vector;
  7 
  8 
  9 import com.library.bean.User;
 10 import com.library.db.DbProvider;
 11 import com.library.mapping.ORM;
 12 import com.library.mapping.UserMapping;
 13 
 14 public class UserImp implements UserDAO
 15 {
 16 
 17     @Override
 18     public User query(String username, String password)
 19     {
 20         // TODO Auto-generated method stub
 21         String sql="select * from user where user_name=? and user_pass=?";
 22         User user=null;
 23         try
 24         {
 25             PreparedStatement ps=DbProvider.newInstance().getconnect().prepareStatement(sql);
 26             ps.setString(1, username);
 27             ps.setString(2, password);
 28             ResultSet rs=ps.executeQuery();
 29             ORM map=new UserMapping();
 30             user=(User) map.mapping(rs);
 31             DbProvider.newInstance().close(ps, rs);
 32         } catch (SQLException e)
 33         {
 34             // TODO Auto-generated catch block
 35             e.printStackTrace();
 36         }
 37         return user;
 38     }
 39 
 40     @Override
 41     public boolean query(int stuid)
 42     {
 43         // TODO Auto-generated method stub
 44         boolean flag=false;
 45         String sql="select * from user where user_id=?";
 46         try
 47         {
 48             PreparedStatement ps=DbProvider.newInstance().getconnect().prepareStatement(sql);
 49             ps.setInt(1, stuid);
 50             ResultSet rs=ps.executeQuery();
 51             while(rs.next())
 52             {
 53                 flag=true;
 54             }
 55             DbProvider.newInstance().close(ps, rs);
 56         } catch (SQLException e)
 57         {
 58             // TODO Auto-generated catch block
 59             e.printStackTrace();
 60         }
 61         return flag;
 62     }
 63 
 64     @Override
 65     public boolean query(String username)
 66     {
 67         boolean flag=false;
 68         String sql="select * from user where user_name=?";
 69         try
 70         {
 71             PreparedStatement ps=DbProvider.newInstance().getconnect().prepareStatement(sql);
 72             ps.setString(1, username);
 73             ResultSet rs=ps.executeQuery();
 74             while(rs.next())
 75             {
 76                 flag=true;
 77             }
 78             DbProvider.newInstance().close(ps, rs);
 79         } catch (SQLException e)
 80         {
 81             // TODO Auto-generated catch block
 82             e.printStackTrace();
 83         }
 84         return flag;
 85     }
 86 
 87     @Override
 88     public int save(User user)
 89     {
 90         // TODO Auto-generated method stub
 91         int i=0;
 92         String sql="insert into user(user_id,user_name,user_pass,private) values(?,?,?,?)";
 93         try
 94         {
 95             PreparedStatement ps=DbProvider.newInstance().getconnect().prepareStatement(sql);
 96             ps.setInt(1, user.getUser_id());
 97             ps.setString(2, user.getUser_name());
 98             ps.setString(3, user.getUser_pass());
 99             ps.setInt(4, user.getPriv());
100             i=ps.executeUpdate();
101             DbProvider.newInstance().close(ps);
102         } catch (SQLException e)
103         {
104             // TODO Auto-generated catch block
105             e.printStackTrace();
106         }
107         return i;
108     }
109 
110     @Override
111     public int update(int id, User user)
112     {
113         // TODO Auto-generated method stub
114         int i=0;
115         String sql="update user set user_id=? , user_name=? , user_pass=? , private=? where id=?";
116         try
117         {
118             PreparedStatement ps=DbProvider.newInstance().getconnect().prepareStatement(sql);
119             ps.setInt(1, user.getUser_id());
120             ps.setString(2, user.getUser_name());
121             ps.setString(3, user.getUser_pass());
122             ps.setInt(4, user.getPriv());
123             ps.setInt(5, user.getId());
124             i=ps.executeUpdate();
125             DbProvider.newInstance().close(ps);
126         } catch (SQLException e)
127         {
128             // TODO Auto-generated catch block
129         }
130         return i;
131     }
132 
133     @Override
134     public int getCount()
135     {
136         int i=0;
137         String sql="select count(id) from user";
138         try
139         {
140             PreparedStatement ps=DbProvider.newInstance().getconnect().prepareStatement(sql);
141             ResultSet rs=ps.executeQuery();
142             while(rs.next())
143             {
144                 i=rs.getInt(1);
145                 
146             }
147             DbProvider.newInstance().close(ps, rs);
148         } catch (SQLException e)
149         {
150             // TODO Auto-generated catch block
151             e.printStackTrace();
152         }
153         return i;
154     }
155 
156     @Override
157     public Vector<Vector<Object>> query()
158     {
159         String sql=" select * from user order by id";
160         Vector<Vector<Object>> vec=new Vector<Vector<Object>>();
161         try
162         {
163             PreparedStatement ps=DbProvider.newInstance().getconnect().prepareStatement(sql);
164             ResultSet rs=ps.executeQuery();
165             while(rs.next())
166             {
167                 
168                 Vector<Object> vector=new Vector<Object>();
169                 vector.addElement(rs.getInt(1));
170                 vector.addElement(rs.getInt(2));
171                 vector.addElement(rs.getString(3));
172                 vector.addElement(rs.getString(4));
173                 vector.addElement(rs.getInt(5)==0 ? "读者" :"管理员");
174                 vec.addElement(vector);
175             }
176             DbProvider.newInstance().close(ps, rs);
177         } catch (SQLException e)
178         {
179             // TODO Auto-generated catch block
180             e.printStackTrace();
181         }
182         return vec;
183     }
184 
185     @Override
186     public int delete(int id)
187     {
188         // TODO Auto-generated method stub
189         int i=0;
190         String sql="delete from user where id="+id;
191         try
192         {
193             PreparedStatement ps=DbProvider.newInstance().getconnect().prepareStatement(sql);
194             
195             i=ps.executeUpdate();
196             DbProvider.newInstance().close(ps);
197         } catch (SQLException e)
198         {
199             // TODO Auto-generated catch block
200             e.printStackTrace();
201         }
202         return i;
203     }
204 
205     @Override
206     public String getUserName(int userId)
207     {
208         String username="";
209         // TODO Auto-generated method stub
210         String sql="select user_name from user where user_id="+userId;
211         
212         try
213         {
214             PreparedStatement ps=DbProvider.newInstance().getconnect().prepareStatement(sql);
215             ResultSet rs=ps.executeQuery();
216             while(rs.next())
217             {
218             username=rs.getString(1);
219             }
220             DbProvider.newInstance().close(ps, rs);
221         } catch (SQLException e)
222         {
223             // TODO Auto-generated catch block
224             e.printStackTrace();
225         }
226         
227         return username;
228     }
229 
230     
231 }

　　数据传值对象:我们也一般会使用三个组件

　　数据表对应的对象类
　　数据传值对象接口
　　实现数据传值接口类

　　数据表对应的对象类:表tb_user对应的对象类User

 1 package com.library.bean;
 2 
 3 public class User
 4 {
 5 
 6     private int id;
 7     private int user_id;
 8     private String user_name;
 9     private String user_pass;
10 
11     public String getUser_pass()
12     {
13         return user_pass;
14     }
15 
16     public void setUser_pass(String userPass)
17     {
18         user_pass = userPass;
19     }
20 
21     private int priv;
22 
23     public int getId()
24     {
25         return id;
26     }
27 
28     public void setId(int id)
29     {
30         this.id = id;
31     }
32 
33     public int getUser_id()
34     {
35         return user_id;
36     }
37 
38     public void setUser_id(int userId)
39     {
40         user_id = userId;
41     }
42 
43     public String getUser_name()
44     {
45         return user_name;
46     }
47 
48     public void setUser_name(String userName)
49     {
50         user_name = userName;
51     }
52 
53     public int getPriv()
54     {
55         return priv;
56     }
57 
58     public void setPriv(int priv)
59     {
60         this.priv = priv;
61     }
62 
63 }

数据传值对象接口ORM

1 package com.library.mapping;
2 
3 import java.sql.ResultSet;
4 
5 
6 public interface ORM
7 {
8     public  Object mapping(ResultSet rs);
9 }

数据传值对象实现类UserMapping

 1 package com.library.mapping;
 2 
 3 
 4 import java.sql.ResultSet;
 5 import java.sql.SQLException;
 6 
 7 import com.library.bean.User;
 8 
 9 public class UserMapping implements ORM
10 {
11 
12     @Override
13     public  User mapping(ResultSet rs)
14     {
15         // TODO Auto-generated method stub
16         User user=null;
17         try
18         {
19             while(rs.next())
20             {
21                 user=new User();
22                 user.setId(rs.getInt(1));
23                 user.setUser_id(rs.getInt(2));
24                 user.setUser_name(rs.getString(3));
25                 user.setUser_pass(rs.getString(4));
26                 user.setPriv(rs.getInt(5));
27             }
28             rs.close();
29         } catch (SQLException e)
30         {
31             // TODO Auto-generated catch block
32             e.printStackTrace();
33         }
34         return user;
35     }
36 
37 }

以上就是DAO模式ORM框架的实现.

posted on 2011-11-08 10:35 海洋天空阅读(531) 评论(1) 收藏举报

刷新页面返回顶部

海洋天空

Hibernate的入门篇(1)

导航

公告