Java学习笔记01

1.原型设计：

将页面的模块、元素、人机交互的形式，利用线框描述的方法，将产品脱离皮肤状态下更加具体跟生动的进行表达.

2.下面的是使用PowerDesigner进行设计的持久层的层次结构图：

虚线三角表示的是“实现接口” 实线三角表示的“继承”

其中，下图使用了依赖倒置的原则：高层模块不应该依赖与底层

其中AbstractBaseDao抽象类是为了有选择性的实现特定功能，采用了设计模式中的模版模式。

上图采用的是门面模式。

3. Hibernate（ORM，即Object-Relational Mapping）对象关系映射：

作用就是在关系型数据库和对象之间做了一个映射。从对象（Object）映射到关系（Relation），再从关系映射到对象。这样，我们在操作数据库的时候，不需要再去和复杂SQL打交道，只要像操作对象一样操作它就可以了（把关系数据库的字段在内存中映射成对象的属性）。

从上图中，我们可以看出Hibernate六大核心接口，两个主要配置文件，以及他们直接的关系。Hibernate的所有内容都在这了。那我们从上到下简单的认识一下，每个接口进行一句话总结。

1、Configuration接口:负责配置并启动Hibernate

2、SessionFactory接口:负责初始化Hibernate

3、Session接口:负责持久化对象的CRUD操作

4、Transaction接口:负责事务

5、Query接口和Criteria接口:负责执行各种数据库查询

注意：Configuration实例是一个启动期间的对象，一旦SessionFactory创建完成它就被丢弃了。

其中：hibernate.cfg.xml事例代码如下：

 <!DOCTYPE hibernate-configuration PUBLIC
     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 
 <hibernate-configuration>
     <session-factory>
         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="hibernate.connection.url">jdbc:mysql://localhost/XXX</property>  //XXX为本地数据库名称
         <property name="hibernate.connection.username">root</property>    //连接数据库账号
         <property name="hibernate.connection.password">root</property>   //连接数据密码
         <property name="hibernate.show_sql">true</property>
         <property name="hibernate.hbm2ddl.auto">update</property>
         <mapping resource="com/djdj/entity/Order.hbm.xml"/>    //mapping 为实体代码到数据库的映射
     </session-factory>
 </hibernate-configuration>
 

  //Order.hbm.xml代码如下：

 1 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 <hibernate-mapping>
     <class name="com.djdj.entity.Order" table="tb_order">  //name为实体类 ，table 为在数据库建的表名称
       <id name="id">
          <generator class="native"></generator>
       </id>
       <property name="orderNo"></property>
 
       <set name="item">
       <key column="orderNo"></key>     //其中key中column的值要跟many-to-one中column的值相等
       <one-to-many class="com.djdj.entity.OrderItem"></one-to-many>       //one-to-many 代表一对多的关系 many-to-one 多对一 many-to-many 代表多对多的关系
15
       </set>
     </class>
 </hibernate-mapping>

实体类Order的代码如下：

package com.djdj.entity;
 
import java.io.Serializable;
import java.util.Set;
 
public class Order implements Serializable{
           private int id;
           private int orderNo;
           private Set<OrderItem> item;
 
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public int getOrderNo() {
            return orderNo;
        }
        public void setOrderNo(int orderNo) {
            this.orderNo = orderNo;
        }
        public Set<OrderItem> getItem() {
            return item;
        }
        public void setItem(Set<OrderItem> item) {
            this.item = item;
        }
 
}

Hibernate调用配置文件创建数据库表的代码如下：

public class CreateTable {
     public static void main(String[] args) {
        //读配置
         Configuration cfg =  new Configuration().configure();
         SchemaExport export = new SchemaExport(cfg);
         export.create(true, true);
    }
}

测试代码如下：

public class Test {
 
    public static void main(String[] args) {
         //读取配置
         Configuration cfg =  new Configuration().configure();
         //获取SessionFactory
         SessionFactory factory =cfg.buildSessionFactory();
         //获取session
         Session session=null;
 
         try{
             session =factory.openSession();
             //开启事务
             session.beginTransaction();
 
             //
             //中间进行数据操作代码的编写
             //
             session.getTransaction().commit();
         }catch (Exception e) {
            e.printStackTrace();
        }finally{
            session.close();
            //离线不更改
            //u.setName("1");
        }
 
    }
 
}

以User为例，实现增删查改的代码如下：

             //设置user
//             User user = new User();
//             user.setName("st2");
//             user.setPwd("1112");
             //save 之前是瞬时对象 ，之后为持久化对象：和数据库数据相关
//             session.save(user);
 
             //查询对象
//             User u=(User)session.get(User.class, 2);
             //load获取代理对象，效率高，只有真正在使用过程中获取真实对象，get直接获取真实对象。
//             User u=(User)session.load(User.class, 2);
//             System.out.println(u.getName());
 
             //删除对象
//             User u=(User)session.get(User.class, 2);
//             System.out.println(u.getName());
            // session.delete(u);
 
             //修改对象
             User u=(User)session.get(User.class, 2);
             System.out.println(u.getName());
             u.setName("sys");
             session.update(u);

级联操作：

Casade用来说明当对主对象进行某种操作时是否对其关联的从对象也作类似的操作，常用的cascade:

none,all,save-update,delete, lock,refresh,evict,replicate,persist,

merge,delete-orphan(one-to-many)。一般对many-to-one,many-to-many不设置级联，在<one-to-one>和<one-to-many>中设置级联。

sagacity_shen

初定于  2017-09-20 00:58:34