Hibernate的CRUD以及junit测试

里氏替换原则,OCP作为OO的高层原则,主张接纳“抽象(Abstraction)”和“多态(Polymorphism)”将设计中的静态结构改为动态结构,维持设计的封闭性。“抽象”是语言提供的法力。“多态”由持续语义完结。

Hibernate的CRUD以及junit测试

概念1:要是对每三个品种为T1的对象 o1,都有品种为 T2 的指标o2,使得以
T1定义的有所程序 P 在具有的对象 o1 都代换来 o2 时,程序 P
的一举一动尚未产生变化,那么类型 T2 是项目 T1 的子类型。

1:第壹步创造动态工程引包,省略。

定义2:富有引用基类的地点必须能透明地运用其子类的靶子。

2:第贰步,创设数据库和数据表,省略。

        
若是您以为定义说的模糊了点,不太掌握,没涉及,大家稳步说领会。里氏替换原则的另3个简约的定义是“全数引用基类的地方必须能透明地选择其子类的对象”。那些可能更清楚点。就算你熟练的主宰一门面向对象的语言,你应有都足以知道面向对象的后续,子类继承自父类的话,自然的就会继续父类的享有办法(当然前提是父类不要把艺术注解为private)。    

3:第贰步,成立实体类,如User.java,源码如下所示:

在面向对象中,继承有不少亮点:

  对于实体类,一般完毕构造方法,而构造方法一般实现多少个:

       1代码共享,缩小创设类的工作量,每一种子类都具有父类的法子和属性;

    一个无参构造方法;

       2进步代码的重用性;

    二个有参的构造方法;

      
3子类能够形似父类,但又异于父类,“龙生龙,凤生凤,老鼠生来会打洞”是说子拥有父的“种”,“世界上未曾两片完全相同的纸牌”是指明子与父的不等;

    3个不带id的构造方法;

      
4进步代码的可扩充性,实现父类的点子就足以“武断专行”了,君不见很多开源框架的增加接口都以经过持续父类来形成的;

 1 package com.bie.po;
 2 /** 
 3 * @author BieHongLi 
 4 * @version 创建时间:2017年3月8日 下午5:17:23 
 5 * 
 6 */
 7 public class User {
 8 
 9     private int id;
10     private String name;
11     private String password;
12     private String email;
13     private String phone;
14     public int getId() {
15         return id;
16     }
17     public void setId(int id) {
18         this.id = id;
19     }
20     public String getName() {
21         return name;
22     }
23     public void setName(String name) {
24         this.name = name;
25     }
26     public String getEmail() {
27         return email;
28     }
29     public void setEmail(String email) {
30         this.email = email;
31     }
32     public String getPhone() {
33         return phone;
34     }
35     public void setPhone(String phone) {
36         this.phone = phone;
37     }
38     public String getPassword() {
39         return password;
40     }
41     public void setPassword(String password) {
42         this.password = password;
43     }
44     @Override
45     public String toString() {
46         return "User [id=" + id + ", name=" + name + ", password=" + password + ", email=" + email + ", phone=" + phone
47                 + "]";
48     }
49     public User(String name, String password, String email, String phone) {
50         super();
51         this.name = name;
52         this.password = password;
53         this.email = email;
54         this.phone = phone;
55     }
56     public User(int id, String name, String password, String email, String phone) {
57         super();
58         this.id = id;
59         this.name = name;
60         this.password = password;
61         this.email = email;
62         this.phone = phone;
63     }
64     public User() {
65         super();
66     }
67     
68     
69 }

       5进步产品或项目标开放性。

4:配置数据表和实体类之间的映照,起名如实体类.hbm.xml,源码如下所示:

 
而里氏替换原则希望,你在写贰个类继承自原有的类的还要,尽量不要去改变原有的不二法门。话说那么多,那么早晚会有疑点。

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5     
 6 <hibernate-mapping package="com.bie.po"> 
 7     <!-- 操作条件:
 8         1:对象与表
 9         2:属性与字段的对应
10         3:类型的对应,类型默认采用属性的类型,type不写的话
11      -->
12     <class name="User" table="user">
13         <!-- 主键,映射 -->
14         <id name="id" column="id">
15             <generator class="native"></generator>
16         </id>
17         
18         <!-- 非主键,映射 -->
19         <property name="name" column="name"></property>
20         <property name="password" column="password"></property>
21         <property name="email" column="email"></property>
22         <property name="phone" column="phone"></property>
23         
24         
25     </class>
26 
27 </hibernate-mapping>

题目原因:有一效果P1,由类A达成。现必要将成效P1进行扩展,扩充后的法力为P,当中P由原有作用P1与新职能P2组成。新功能P由类A的子类B来成功,则子类B在成功新作用P2的还要,有可能会促成原本职能P1爆发故障。

5:完毕实体类和数据表之间的布置,就先河配备数据库连接和加载映射,hibernate,cfg.xml

缓解方案:当使用持续时,遵循里氏替换原则。类B继承类A时,除添加新的主意成功新增成效P2外,尽量不要重写父类A的法门,也尽恐怕不要重载父类A的章程。

 1 <!DOCTYPE hibernate-configuration PUBLIC
 2     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 3     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 4 
 5 <hibernate-configuration>
 6     <session-factory>
 7         <!-- 
 8             1:数据连接配置
 9             2:加载所有的映射(*.hbm.xml)
10          -->
11          
12          <!-- 1:数据连接配置 -->
13          <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
14          <property name="hibernate.connection.url">jdbc:mysql:///test</property>
15          <property name="hibernate.connection.username">root</property>
16          <property name="hibernate.connection.password">123456</property>
17          <!-- mysql数据库的方言 -->
18          <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
19          
20          <property name="hibernate.show_sql">true</property>
21          
22          <!-- 2:加载所有的映射(*.hbm.xml) -->
23          <mapping resource="com/bie/po/User.hbm.xml"/>
24          
25     </session-factory>
26 </hibernate-configuration>

        
继承包蕴那样一层意思:父类中凡是已经落实好的办法(相对于肤浅方法而言),实际上是在设定一层层的规范和契约,固然它不强制需求有所的子类必须信守这个契约,但是假如子类对这么些非抽象方法任意修改,就会对一切继承种类造成损坏。而里氏替换原则就是发布了这一层含义。

 6:提取工具类HibernateUtils.java,简化开发:

       
继承作为面向对象三大特征之一,在给程序设计带来巨大便利的同时,也带来了弊端。比如利用持续会给程序带来侵入性,程序的可移植性下降,扩展了对象间的耦合性,假设三个类被其余的类所继承,则当这几个类供给修改时,必须考虑到全部的子类,并且父类修改后,全体涉嫌到子类的功效都有可能会生出故障。

 1 package com.bie.utils;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.cfg.Configuration;
 6 
 7 /** 
 8 * @author BieHongLi 
 9 * @version 创建时间:2017年3月10日 下午1:47:55 
10 * 创建工具类
11 */
12 public class HibernateUtils {
13 
14     private static SessionFactory sf;
15     static{
16         //加载主配置文件,并且创建session的工厂
17         sf=new Configuration().configure().buildSessionFactory();
18     }
19     
20     //创建session对象
21     public static Session getSession(){
22         return sf.openSession();
23     }
24 }

       
举例表达继承的高风险,大家须要完毕叁个两数相减的效益,由类A来担负。

7:最终成功Dao层的交替,由事先运用的主干的Connection创立连接替换来为session创设连接;

class A{
    public int func1(int a, int b){
        return a-b;
    }
}

public class Client{
    public static void main(String[] args){
        A a = new A();
        System.out.println("100-50="+a.func1(100, 50));
        System.out.println("100-80="+a.func1(100, 80));
    }
}

  首先创造接口再落到实处接口;

运维结果:

  注意:

100-50=50
100-80=20

     更新的时候,索引是从0开头的,不是从1早先的,切记;

 后来,我们须求充实二个新的功用:实现两数相加,然后再与100求和,由类B来负担。即类B要求形成八个成效:

图片 1图片 2

  • 两数相减。
  • 两数相加,然后再加100。
 1 package com.bie.dao;
 2 
 3 import java.util.List;
 4 
 5 import com.bie.po.User;
 6 
 7 /** 
 8 * @author BieHongLi 
 9 * @version 创建时间:2017年3月10日 下午1:35:14 
10 * 
11 */
12 public interface UserDao {
13 
14     /***
15      * 用户信息保存的方法
16      * @param user
17      */
18     public void insertUser(User user);
19     
20     
21     /***
22      * 用户信息更改的方法
23      * @param user
24      */
25     public void updateUser(User user);
26     
27     
28     /***
29      * 根据用户的编号用户信息查询的方法
30      * @param id
31      * @return
32      */
33     public User selectUserId(int id);
34     
35     
36     /**
37      * 用户查询所有的信息
38      * @return
39      */
40     public List<User> selectAll();
41     
42     /***
43      * 
44      * @param name
45      * @return
46      */
47     public List<User> selectAll(String name);
48     
49     /***
50      * 分页查询的方法
51      * @param index
52      * @param count
53      * @return
54      */
55     public List<User> selectPage(int index,int count);
56     
57     /***
58      * 删除的方法
59      * @param id
60      */
61     public void deleteUser(int id);
62 }

       
由于类A已经落到实处了第3个职能,所以类B继承类A后,只须求再形成第二个效益就足以了,代码如下:

View Code

class B extends A{
    public int func1(int a, int b){
        return a+b;
    }

    public int func2(int a, int b){
        return func1(a,b)+100;
    }
}

public class Client{
    public static void main(String[] args){
        B b = new B();
        System.out.println("100-50="+b.func1(100, 50));
        System.out.println("100-80="+b.func1(100, 80));
        System.out.println("100+20+100="+b.func2(100, 20));
    }
}
  1 package com.bie.dao.impl;
  2 
  3 import java.util.List;
  4 
  5 import org.hibernate.Query;
  6 import org.hibernate.Session;
  7 import org.hibernate.Transaction;
  8 
  9 import com.bie.dao.UserDao;
 10 import com.bie.po.User;
 11 import com.bie.utils.HibernateUtils;
 12 
 13 /** 
 14 * @author BieHongLi 
 15 * @version 创建时间:2017年3月10日 下午1:35:27 
 16 * 
 17 */
 18 public class UserDaoImpl implements UserDao{
 19 
 20     @Override
 21     public void insertUser(User user) {
 22         Session session=null;
 23         Transaction tx=null;
 24         try {
 25             //获取session
 26             session=HibernateUtils.getSession();
 27             //开启事务
 28             tx=session.beginTransaction();
 29             //插入即保存
 30             session.save(user);
 31         } catch (Exception e) {
 32             throw new RuntimeException(e);
 33         }finally{
 34             //提交事务
 35             tx.commit();
 36             //关闭session
 37             session.close();
 38         }
 39         
 40     }
 41 
 42     @Override
 43     public void updateUser(User user) {
 44         Session session=null;
 45         Transaction tx=null;
 46         try {
 47             session=HibernateUtils.getSession();
 48             tx=session.beginTransaction();
 49             session.update(user);
 50         } catch (Exception e) {
 51             throw new RuntimeException(e);
 52         }finally{
 53             //提交事务
 54             tx.commit();
 55             //关闭事务
 56             session.close();
 57         }
 58         
 59     }
 60 
 61     @Override
 62     public User selectUserId(int id) {
 63         //获取session
 64         Session session=null;
 65         //事务
 66         Transaction tx=null;
 67         try {
 68             //获取session
 69             session=HibernateUtils.getSession();
 70             //开启事务
 71             tx=session.beginTransaction();
 72             
 73             return (User)session.get(User.class, id);
 74         } catch (Exception e) {
 75             throw new RuntimeException(e);
 76         }finally{
 77             //提交事务
 78             tx.commit();
 79             //关闭session
 80             session.close();
 81         }
 82     }
 83 
 84     @Override
 85     public List<User> selectAll() {
 86         //session
 87         Session session=null;
 88         //事务
 89         Transaction tx=null;
 90         try {
 91             //获取session
 92             session=HibernateUtils.getSession();
 93             //开启事务
 94             tx=session.beginTransaction();
 95             //HQL语句
 96             Query q=session.createQuery("from User");
 97             
 98             List<User> list=q.list();
 99             return list;
100         } catch (Exception e) {
101             throw new RuntimeException(e);
102         }finally{
103             //提交事务
104             tx.commit();
105             //关闭session
106             session.close();
107         }
108     }
109 
110     @Override
111     public List<User> selectAll(String name) {
112         //session
113         Session session=null;
114         //事务
115         Transaction tx=null;
116         try {
117             //获取session
118             session=HibernateUtils.getSession();
119             //开启事务
120             tx=session.beginTransaction();
121             //HQL语句
122             Query q = session.createQuery("from User user where user.name=? ");
123             //注意:参数索引从0开始
124             q.setString(0, name);
125             
126             return q.list();
127         } catch (Exception e) {
128             throw new RuntimeException();
129         }finally{
130             //提交事务
131             tx.commit();
132             //关闭session
133             session.close();
134         }
135     }
136 
137     @Override
138     public List<User> selectPage(int index, int count) {
139         //session
140         Session session=null;
141         //事务
142         Transaction tx=null;
143         try {
144             //获取session
145             session=HibernateUtils.getSession();
146             //开启事务
147             tx=session.beginTransaction();
148             //HQL查询
149             Query q = session.createQuery("from User ");
150             //设置分页参数
151             q.setFirstResult(index);//查询起始行
152             q.setMaxResults(count);//查询返回的行数
153             
154             return q.list();
155         } catch (Exception e) {
156             throw new RuntimeException();
157         }finally{
158             //提交事务
159             tx.commit();
160             //关闭session
161             session.close();
162         }
163     }
164 
165     @Override
166     public void deleteUser(int id) {
167         Session session=null;
168         Transaction tx=null;
169         try {
170             session=HibernateUtils.getSession();
171             tx=session.beginTransaction();
172             //先根据id查询出用户的信息再删除
173             Object obj=session.get(User.class, id);
174             if(obj!=null){
175                 session.delete(obj);
176             }
177         } catch (Exception e) {
178             throw new RuntimeException();
179         }finally{
180             //提交事务
181             tx.commit();
182             //关闭session
183             session.close();
184         }
185     }
186 
187     
188 }

类B实现后,运转结果:

8:最终一步,完结测试。源码如下所示:

100-50=150
100-80=180
100+20+100=220
 1 package com.bie.test;
 2 
 3 import java.util.List;
 4 
 5 import org.junit.Test;
 6 
 7 import com.bie.dao.UserDao;
 8 import com.bie.dao.impl.UserDaoImpl;
 9 import com.bie.po.User;
10 
11 /** 
12 * @author BieHongLi 
13 * @version 创建时间:2017年3月10日 下午2:34:48 
14 * 
15 */
16 public class UserCRUD {
17 
18     private UserDao dao=new UserDaoImpl();
19     
20     @Test
21     public void insertUser(){
22         dao.insertUser(new User("曹操","111","111111","111111@163.com"));
23         
24     }
25     
26     @Test
27     public void updateUser(){
28         User user=new User();
29         user.setId(1);
30         user.setName("刘备222");
31         
32         dao.updateUser(user);
33     }
34     
35     @Test
36     public void deleteUser(){
37         dao.deleteUser(30);
38     }
39     
40     @Test
41     public void selectUserId(){
42         //根据用户的编号进行查询
43         User user=dao.selectUserId(1);
44         System.out.println(user);
45     }
46     
47     @Test
48     public void selectUser(){
49         //查询用户的所有信息
50         List<User> list = dao.selectAll();
51         System.out.println(list);
52     }
53     
54     @Test
55     public void selectUserName(){
56         //根据用户姓名查询信息
57         List<User> list=dao.selectAll("李四");
58         System.out.println(list);
59     }
60     
61     @Test
62     public void selectPage(){
63         //分页查询,第一个参数是起始行,第二个参数是每页的个数
64         List<User> list=dao.selectPage(0, 5);
65         System.out.println(list);
66     }
67 }

 大家发现原先运转符合规律化的相减作用发生了不当。原因就是类B在给艺术起名时无意中重写了父类的不二法门,造成全部运转相减效率的代码全体调用了类B重写后的方法,造成原本运营平常的效应出现了不当。在本例中,引用基类A完毕的效益,换到子类B之后,产生了老大。在实质上编制程序中,大家平时会透过重写父类的主意来成功新的法力,这样写起来即使简易,不过任何继承种类的可复用性会比较差,尤其是利用多态相比频仍时,程序运营出错的可能率相当的大。假使非要重写父类的艺术,相比通用的做法是:原来的父类和子类都连任3个更通俗的基类,原有的持续关系去掉,采取注重、聚合,组合等涉及代替。

运作效果如下所示:

       
里氏替换原则通俗的来讲正是:子类能够扩展父类的效能,但无法更改父类原有的功用。它蕴涵以下4层意思:

图片 3

  • 子类能够完毕父类的架空方法,但无法遮住父类的非抽象方法。
  • 子类中得以追加和谐特有的情势。
  • 当子类的办法重载父类的办法时,方法的放手条件(即方法的形参)要比父类方法的输入参数更宽松。
  • 当子类的措施完成父类的悬空方法时,方法的前置条件(即方法的再次回到值)要比父类更严刻。

       
看上去很不可捉摸,因为我们会意识在和谐编制程序中平时会违反里氏替换原则,程序依旧跑的美貌的。所以大家都会发出如此的疑团,若是作者非要不遵照里氏替换原则会有啥样结果?

路在远处,人丑就该多码Coding!!!

        后果就是:您写的代码出标题标可能率将会大大增添。

 

转载于http://blog.csdn.net/zhengzhb/article/details/7281833

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图