对象增删改查与SQL查询

1. package Dao;  
2.   
3. import java.util.List;  
4.   
5. import org.hibernate.Query;  
6. import org.hibernate.Session;  
7. import org.hibernate.Transaction;  
8. import org.junit.Test;  
9.   
10. import domain.User;  
11. import utils.HibernateUtils;  
12.   
13. public class UserDao {  
14.     //增加用户  
15.     @Test  
16.     public void addUser(){  
17.         Session session = null;  
18.         Transaction ts = null;  
19.         try {  
20.             session = HibernateUtils.getSession();  
21.             ts = session.beginTransaction();  
22.               
23.             User user = new User();//瞬时对象  
24.             user.setName("小王");  
25.             user.setSex("女");  
26.             user.setAge(33);  
27.             user.setHeight(180);  
28.             user.setHobby("做饭");  
29.               
30.             session.save(user);//持久对象  
31.             ts.commit();  
32.               
33.         } catch (Exception e) {  
34.             if(ts != null)  
35.             {  
36.                 ts.rollback();  
37.             }  
38.             e.printStackTrace();  
39.         }  
40.     }  
41.     //查询用户  
42.     @Test  
43.     public void findUser(){  
44.         Session session = null;  
45.         Transaction ts = null;  
46.         try {  
47.             session = HibernateUtils.getSession();  
48.             ts = session.beginTransaction();  
49.               
50.             User user = session.get(User.class, 4);//持久对象  
51.             System.out.println(user);  
52.               
53.             ts.commit();  
54.               
55.         } catch (Exception e) {  
56.             if(ts != null)  
57.             {  
58.                 ts.rollback();  
59.             }  
60.             e.printStackTrace();  
61.         }  
62.     }  
63.     //修改用户  
64.     @Test  
65.     public void updateUser(){  
66.         Session session = null;  
67.         Transaction ts = null;  
68.         try {  
69.             session = HibernateUtils.getSession();  
70.             ts = session.beginTransaction();  
71.               
72.             User user = session.get(User.class, 4);  
73.             user.setAge(25);  
74.             user.setHobby("吃饭");  
75.             session.update(user);//持久对象  
76.             System.out.println(user);  
77.               
78.             ts.commit();  
79.               
80.         } catch (Exception e) {  
81.             if(ts != null)  
82.             {  
83.                 ts.rollback();  
84.             }  
85.             e.printStackTrace();  
86.         }  
87.     }  
88.     //删除用户  
89.     @Test  
90.     public void deleteUser(){  
91.         Session session = null;  
92.         Transaction ts = null;  
93.         try {  
94.             session = HibernateUtils.getSession();  
95.             ts = session.beginTransaction();  
96.               
97.             User user = session.get(User.class, 6);  
98.             session.delete(user);  
99.             System.out.println(user);  
100.               
101.             ts.commit();  
102.               
103.         } catch (Exception e) {  
104.             if(ts != null)  
105.             {  
106.                 ts.rollback();  
107.             }  
108.             e.printStackTrace();  
109.         }  
110.     }  
111.       
112.     //简单查询  
113.     @Test  
114.     public void queryUser(){  
115.         Session session = null;  
116.         Transaction ts = null;  
117.         try {  
118.             session = HibernateUtils.getSession();  
119.             ts = session.beginTransaction();  
120.               
121.             Query query = session.createQuery("from User");  
122.             List<User> users = query.list();  
123.             for (User user : users) {  
124.                 System.out.println(user);  
125.             }  
126.               
127.             ts.commit();  
128.               
129.         } catch (Exception e) {  
130.             if(ts != null)  
131.             {  
132.                 ts.rollback();  
133.             }  
134.             e.printStackTrace();  
135.         }  
136.     }  
137.     //属性查询  
138.     @Test  
139.     public void queryUserName(){  
140.         Session session = null;  
141.         Transaction ts = null;  
142.         try {  
143.             session = HibernateUtils.getSession();  
144.             ts = session.beginTransaction();  
145.               
146.             Query query = session.createQuery("select u.name from User u");  
147.             List<String> names = query.list();  
148.             for (String user : names) {  
149.                   
150.                 System.out.println(user);  
151.             }  
152.               
153.             ts.commit();  
154.               
155.         } catch (Exception e) {  
156.             if(ts != null)  
157.             {  
158.                 ts.rollback();  
159.             }  
160.             e.printStackTrace();  
161.         }  
162.     }  
163.     //实例化查询  
164.     @Test  
165.     public void queryUserExample(){  
166.         Session session = null;  
167.         Transaction ts = null;  
168.         try {  
169.             session = HibernateUtils.getSession();  
170.             ts = session.beginTransaction();  
171.               
172.             Query query = session.createQuery("from User where age = 21");  
173.             List<User> users = query.list();  
174.             for (User user : users) {  
175.                 System.out.println(user);  
176.             }  
177.               
178.             ts.commit();  
179.               
180.         } catch (Exception e) {  
181.             if(ts != null)  
182.             {  
183.                 ts.rollback();  
184.             }  
185.             e.printStackTrace();  
186.         }  
187.     }  
188.     //统计查询  
189.     @Test  
190.     public void queryUserGroup(){  
191.         Session session = null;  
192.         Transaction ts = null;  
193.         try {  
194.             session = HibernateUtils.getSession();  
195.             ts = session.beginTransaction();  
196.               
197.             Query query = session.createQuery("select avg(u.age) from User u");  
198.             Number avgage = (Number) query.uniqueResult();  
199.             System.out.println("平均年龄为："+avgage);  
200.             ts.commit();  
201.               
202.         } catch (Exception e) {  
203.             if(ts != null)  
204.             {  
205.                 ts.rollback();  
206.             }  
207.             e.printStackTrace();  
208.         }  
209.     }  
210.     //子查询  
211.     @Test  
212.     public void queryUserIn(){  
213.         Session session = null;  
214.         Transaction ts = null;  
215.         try {  
216.             session = HibernateUtils.getSession();  
217.             ts = session.beginTransaction();  
218.               
219.             Query query = session.createQuery("from User u where u.age>(select avg(age) from User)");  
220.             User user = null;  
221.             List list = query.list();  
222.             for (int i =0;i<list.size();i++) {  
223.                 user = (User) list.get(i);  
224.                 System.out.println(i+"姓名："+user.getName()+"——年龄："+user.getAge());  
225.             }  
226.             ts.commit();  
227.               
228.         } catch (Exception e) {  
229.             if(ts != null)  
230.             {  
231.                 ts.rollback();  
232.             }  
233.             e.printStackTrace();  
234.         }  
235.     }  
236. }