HIbernate框架的搭建与运用

HIbernate框架的搭建与运用

1.首先在pom.xml文件中导入以下架包

maven项目可在该网站下下载架包https://mvnrepository.com/

  <dependencies>

      <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.8.8</version>
      </dependency>

      <!--hibernate的jar包-->
      <dependency>
          <groupId>org.hibernate</groupId>
          <artifactId>hibernate-core</artifactId>
          <version>4.1.12.Final</version>
      </dependency>
      <dependency>
          <groupId>org.hibernate.common</groupId>
          <artifactId>hibernate-commons-annotations</artifactId>
          <version>4.0.5.Final</version>
      </dependency>

      <!-- struts2-core的jar包 -->
      <dependency>
          <groupId>org.apache.struts</groupId>
          <artifactId>struts2-core</artifactId>
          <version>2.1.6</version>
      </dependency>
      <dependency>
          <groupId>org.apache.struts.xwork</groupId>
          <artifactId>xwork-core</artifactId>
          <version>2.3.34</version>
      </dependency>

      <!-- oracle数据库 的jar包 -->
      <dependency>
          <groupId>com.oracle</groupId>
          <artifactId>ojdbc6</artifactId>
          <version>11.2.0.1.0</version>
      </dependency>
      
      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.0.1</version>
          <scope>provided</scope>
      </dependency>

      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
      </dependency>

  </dependencies>

1.ojdbc数据库架包的引用

​ 1.先下载一个架包

​ 2.然后找到E:\开发工具\orcale\apache-maven-3.6.1\bin该目录并在cmd中cd到该目录

​ 3.然后运行mvn install:install-file -Dfile=c:\ojdbc6.jar -DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=11.2.0.1.0 -Dpackaging=jar

2.在jsp页面引用jquery架包

<script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.js"></script>

2.配置相关xml文件

resources/mapping/SysPosition.hbm.xml(实体类的映射文件)

​ resources/hibernate.cfg.xml（数据库连接）

​ resources/struts.xml*（前后台数据交互引用action）

1.数据库连接文件xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="connection.url">
            jdbc:oracle:thin:@localhost:1521:orcl
        </property>
        <property name="connection.username">system</property>
        <property name="connection.password">orcl</property>
        <property name="connection.driver_class">
            oracle.jdbc.driver.OracleDriver
        </property>
        <property name="dialect">
            org.hibernate.dialect.Oracle10gDialect
        </property>
        <property name="current_session_context_class">thread</property>
        <property name="show_sql">true</property>
        <property name="format_sql">false</property>
        
        <!--引用-->
        <mapping resource="mapping/SysPosition.hbm.xml"/>

    </session-factory>
</hibernate-configuration>

2.实体类的映射文件xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.zhiwen.entity">
    <class name="SysDepartment" table="SYS_DEPARTMENT">
        <id name="id">
            <generator class="increment"/>
        </id>
        <property name="name" column="NAME"/>

    </class>
</hibernate-mapping>

3.struts.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <package name="web" extends="struts-default">
        <interceptors>
            <interceptor name="myIntecertor" class="com.zhiwen.interceptor.MyIntecertor"/>
            <interceptor-stack name="myStack">
                <interceptor-ref name="defaultStack"></interceptor-ref>
                <interceptor-ref name="myIntecertor"></interceptor-ref>
            </interceptor-stack>
        </interceptors>
        <default-interceptor-ref name="myStack"/>
        <default-action-ref name="default"></default-action-ref>
        <!--全局-->
       <global-results>
            <result name="input">login.jsp</result>
        </global-results>
        <!--  拦截后-->
        <action name="defaulclaimVoucher_getClaimVoucherByIdt">
            <result>login.jsp</result>
        </action>


        <action name="login" class="com.zhiwen.action.Workaction" method="login">
            <result name="success">index.jsp</result>
            <result name="ERROR">login.jsp</result>
            <!--     <result name="users" type="redirectAction">pageinfos</result>
                <result name="users" >page/house_list.jsp</result>-->
        </action>

    </package>
</struts>

3.增删改查工具类

public class HibernateUtil {
    private static  SessionFactory sessionFactory=null;
    static {
        Configuration conf=new Configuration().configure();
        sessionFactory=conf.buildSessionFactory();
    }
    <!--openSession需要关闭-->
    public static Session openSession(){
        return sessionFactory.openSession();
    }

    public static Session getCurrentSession(){
        return sessionFactory.getCurrentSession();
    }
}

1.查询

1.按条件查询

 public SysEmployee QueryloginInfo(SysEmployee sysEmployee) {
        Session session = HibernateUtil.openSession();
        String hql="  from  SysEmployee  where sn=:sn and password=:password  ";
        Query query = session.createQuery(hql);
        query.setProperties(sysEmployee);
        return (SysEmployee) query.uniqueResult();
    }

2.类查询，按id查询

public SysPosition Queryppostion(SysPosition sysPosition) {
    Session session = HibernateUtil.openSession();
    SysPosition s = (SysPosition) session.get(SysPosition.class,sysPosition.getId() );
    return s;
}

3.分页和按条件查询

public List<BizClaimVoucher> QueryBizClaimVoucher(BizClaimVoucher bizClaimVoucher,int  pagesiz,int pageNo) {
    Session session = HibernateUtil.openSession();
    String  hql="from  BizClaimVoucher where 1=1 ";
    if(bizClaimVoucher!=null){
        //用户
        if(bizClaimVoucher.getCreator()!=null&&!"".equals(bizClaimVoucher.getCreator())){
            hql+=" and  creator=:creator";
        }

     hql+=" order by createTime desc ";
        
    }
    Query query = session.createQuery(hql);
    query.setFirstResult((pageNo-1)*pagesiz);
    query.setMaxResults(pagesiz);
    <!--对象传值查询-->
    query.setProperties(bizClaimVoucher);
    
    /*query.setParameter("aa",11);*/  //键值对条件查询
    return  query.list();
}

2.删除

2.1sql语句删除

public void DeleteoneBizClaimVoucherDetail(BizClaimVoucherDetail bizClaimVoucherDetail) {
    Session session=HibernateUtil.openSession();
    System.out.println(bizClaimVoucherDetail.getBizClaimVoucher());
    String hql="delete from BIZ_CLAIM_VOUCHER_DETAIL where 	id="+bizClaimVoucherDetail.getId();
    Query query = session.createSQLQuery(hql);
    /*session.createSQLQuery(hql);*/   //原生sql语句删除

}

2.2类查询然后删除

public void DeleteBizClaimVoucher(BizClaimVoucher bizClaimVoucher) {
    Session session=HibernateUtil.getCurrentSession();
    BizClaimVoucher   biz  =(BizClaimVoucher) session.get(BizClaimVoucher.class,bizClaimVoucher.getId());
    session.delete(biz);

}
<!--报错可能需要开启事务提交-->

2.3更新

 Session session=HibernateUtil.getCurrentSession();
String hql=”update User user set user.age=20 where user.age=18”;
Query queryupdate=session.createQuery(hql);
int ret=queryupdate.executeUpdate();
trans.commit();

2.4插入

public Serializable SaveBizClaimVoucher(BizClaimVoucher bizClaimVoucher) {
    Session session = HibernateUtil.getCurrentSession();
    return session.save(bizClaimVoucher);
}

4.拦截器

public class MyIntecertor extends AbstractInterceptor {
    public String intercept(ActionInvocation ai) throws Exception {
        /*获取登陆对象*/
   Object sysEmployees=ai.getInvocationContext().getSession().get("sysEmployees");
        String urlpath=ai.getInvocationContext().getName();
        System.out.println(urlpath);
            if (null !=sysEmployees||"login".equals(urlpath)){
                //用户存在
                return ai.invoke();
            }

        return "input";
    }
}

5.过滤器（注意导包）

import com.zhiwen.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

public class Myfilter implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        req.setCharacterEncoding("UTF-8");
        Session session = null;
        Transaction transaction = null;
        try {
            session = HibernateUtil.getCurrentSession();
            transaction = session.beginTransaction();

            filterChain.doFilter(req,response);

            transaction.commit();
        } catch (Exception e) {
            transaction.rollback();
        }
    }

    public void destroy() {

    }
}

6.一对多，多对一，多对多的配置

1.[](javascript:void(0)😉

package cn.bdqn.bean;
/**
 * 
 * @author 小豆腐
 *街道对应的实体类
 *
 *单向的多对一关联
 */
public class Street {
    
    private Integer id;
    private String name;
    //多个街道  属于  一个区县
    private    District district;  //对应的区县
    
    
    
    public District getDistrict() {
        return district;
    }
    public void setDistrict(District district) {
        this.district = district;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Street(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public Street() {
        super();
    }
    @Override
    public String toString() {
        return "Street [id=" + id + ", name=" + name + "]";
    }
    
    

}

[](javascript:void(0)😉

[](javascript:void(0)😉

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.bdqn.bean">
  <class name="Street">
       <id name="id"> 
          <generator class="assigned"/><!-- 手动给主键赋值 -->
       </id>  
       <property name="name"/>
       <!-- 配置多对一关联
       name:对应的是  本类中 关联关系的属性名
       column:对应数据库中 两个表的  外键！
       class:关联的实体类-->
       <many-to-one name="district" column="districtId" class="District"/> 
  </class>
</hibernate-mapping>

[](javascript:void(0)😉

[](javascript:void(0)😉

package cn.bdqn.bean;
/**
 * @author 小豆腐
 *
 *区县的实体类
 */
public class District {

    private Integer id;
    private String name;
    
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public District(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public District() {
        super();
    }
    @Override
    public String toString() {
        return "Street [id=" + id + ", name=" + name + "]";
    }
    
    

}

[](javascript:void(0)😉

[](javascript:void(0)😉

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.bdqn.bean">
    <class name="District">
       <id name="id"> 
          <generator class="assigned"/><!-- 手动给主键赋值 -->
       </id>  
       <property name="name"/>
  </class>
</hibernate-mapping>

[](javascript:void(0)😉

需要在hibernate.cfg.xml文件中 配置映射文件

测试类

[](javascript:void(0)😉

        Session session=null;
        Transaction transaction=null;
        
        
        //获取session  开启事务
        @Before
        public  void  before(){
            session=HibernateSessionUtil.getCurrentSession();
            transaction= session.beginTransaction();
        }
    
        
        /**
         * 测试单向的多对一的关联
         * 
         * 创建对应的区县    新增几个区县   以备后续使用
         */
        @Test
        public   void   testAdd(){
            District district=new District(3, "区县3");
            session.save(district);  //保存
            transaction.commit();  //提交事务
        }
        
    
    
    //新增 街道的同时 给街道对应的区县赋值
    @Test
    public   void   test01(){
        //创建一个街道
        Street street=new Street();
        street.setId(1);
        street.setName("街道1");
        //给对应的区县赋值
        District district= (District) session.load(District.class, 1);
        street.setDistrict(district);
        session.save(street);  //保存
        transaction.commit();  //提交事务   只会产生一条sql  insert
    }
    
    //修改 街道对应的区县 
    @Test
    public   void   test02(){
        //从数据库中获取一个街道
        Street street=(Street) session.load(Street.class, 1);  // 对应的区县是1
        District district=(District) session.load(District.class, 2);  // 区县是2
        //修改
        street.setDistrict(district);  // 不需要 update  因为两个对象都是持久化对象
        //提交事务
        transaction.commit();
    }
    
    //删除 街道对应的区县 
    @Test
    public   void   test03(){
        //从数据库中获取一个街道
        Street street=(Street) session.load(Street.class, 1);  // 对应的区县是2
        //修改
        street.setDistrict(null);  
        //提交事务
        transaction.commit();
    }
    

[](javascript:void(0)😉

双向的一对多关联就是在单向多对一的基础上增加一个单向的一对多!

修改District代码 一对多关联

[](javascript:void(0)😉

package cn.bdqn.bean;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 小豆腐
 *
 *区县的实体类
 *  一对多的关联关系
 */
public class District {

    private Integer id;
    private String name;
    // 一个区县 有  多个街道
    private List<Street> streets=new ArrayList<>();
    
    
    public List<Street> getStreets() {
        return streets;
    }
    public void setStreets(List<Street> streets) {
        this.streets = streets;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public District(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public District() {
        super();
    }
    @Override
    public String toString() {
        //如果写成streets   会出现 堆栈溢出的异常！
        return "District [id=" + id + ", name=" + name + ", streets=" + streets.size()
                + "]";
    }
    
    
    
    

}

[](javascript:void(0)😉

修改District.hbm.xml文件代码

[](javascript:void(0)😉

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.bdqn.bean">
    <class name="District">
       <id name="id"> 
          <generator class="assigned"/><!-- 手动给主键赋值 -->
       </id>  
       <property name="name"/>
       <!-- 设置一对多  
       name:本类中的关联属性名  集合的名称
       column: 就是数据库表中的外键
       order-by="id desc" 按照 街道的id 进行 降序排列
       inverse：是由谁来维护表与表之间的关系！ 默认是false！（维护）    true（不维护）
       -->
       <bag name="streets" cascade="all" inverse="true">
        <key column="districtId"/>
         <one-to-many class="Street"/>
       </bag>
  </class>
</hibernate-mapping>

[](javascript:void(0)😉

在测试类中增加代码

[](javascript:void(0)😉

    /**
     * 创建几个街道      测试 双向的一对多关联
     */
    @Test
    public   void   test04(){
        Street street=new Street();
        street.setId(4);
        street.setName("街道4");
        //给对应的区县赋值
        District district= (District) session.load(District.class, 1);
        street.setDistrict(district);
        session.save(street);  //保存
        //提交事务
        transaction.commit();
    }
    
    //根据区县  获取所管辖的街道
    @Test
    public  void  test05(){
    District district=(District) session.load(District.class, 1);
        List<Street> streets = district.getStreets();
        for (Street street : streets) {
            System.out.println(street);
        }
    }
    /**
     * 根据区县  获取所管辖的街道       根据街道的编号 降序排列
     * 01.只需要在 bag节点中  增加 order-by属性  =  id   desc
     */
    @Test
    public  void  test06(){
        District district=(District) session.load(District.class, 1);
        List<Street> streets = district.getStreets();
        for (Street street : streets) {
            System.out.println(street);
        }
    }
    /**
     * 02.使用hql语句
     */
    @Test
    public  void  test07(){
        String  hql="from  Street s where districtId=:id  order by s.id desc";
        //创建query对象
        Query query = session.createQuery(hql);
        //给参数赋值
        query.setParameter("id", 1);   //区县编号是1
        //遍历结果集
        List<Street> list = query.list();
        for (Street street : list) {
            System.out.println(street);
        }
    }
    
    /**
     * cascade属性：定义的是关系两端 对象到对象的级联关系！
     *  必须是  双向的一对多关联！
     *  
     *  常用的属性值：
     *  01.none：默认值！当session操作当前对象的时候，忽略关联的属性！
     *  02.save-update:当session调用save,saveorUpdate以及update()的时候！
     *                会级联的保存和修改当前对象以及对象关联的属性！
     *          001.去区县的xml文件中 的 bag节点 增加 cascade属性！    
     *          002.直接运行以下代码 
     *  03.delete: 当session调用 delete（）的时候，会级联删除所关联的对象  ！
     *  04.all： 包括了save-update和delete！
     * 
     * 添加区县的同时 添加街道
     */
    @Test
    public  void  test08(){
        //创建区县
        District district=new District(4, "区县4");
        //创建街道
        Street street1=new Street(5, "街道5");
        Street street2=new Street(6, "街道6");
        Street street3=new Street(7, "街道7");
        //给区县的街道赋值
        district.getStreets().add(street1);
        district.getStreets().add(street2);
        district.getStreets().add(street3);
        //保存区县
        session.save(district);   //发现 保存了 区县  但是 没有保存对应的街道！
        transaction.commit();
        /**
         * 程序执行之后的结果：
         *  Hibernate: insert into District (name, id) values (?, ?)
            Hibernate: update Street set districtId=? where id=?
            Hibernate: update Street set districtId=? where id=?
            Hibernate: update Street set districtId=? where id=?
         */
        
        /**
         * 在xml文件中设置了 cascade="save-update" 之后的结果
         * 
         * 问题：虽然级联保存成功了！
         *     但是有多余update语句！
         *     为什么会出现多余的？   两个对象都在维护彼此之间的关系！
         * 
         *  Hibernate: select street_.id, street_.name as name1_, street_.districtId as districtId1_ from Street street_ where street_.id=?
            Hibernate: select street_.id, street_.name as name1_, street_.districtId as districtId1_ from Street street_ where street_.id=?
            Hibernate: select street_.id, street_.name as name1_, street_.districtId as districtId1_ from Street street_ where street_.id=?
            Hibernate: insert into District (name, id) values (?, ?)
            Hibernate: insert into Street (name, districtId, id) values (?, ?, ?)
            Hibernate: insert into Street (name, districtId, id) values (?, ?, ?)
            Hibernate: insert into Street (name, districtId, id) values (?, ?, ?)
            Hibernate: update Street set districtId=? where id=?
            Hibernate: update Street set districtId=? where id=?
            Hibernate: update Street set districtId=? where id=?
         */
    }
    
    
    /**
     * cascade="delete"    xml中的配置
     * 删除 区县 的同时 删除 街道！
     */
    @Test
    public  void  test09(){
        District  district= (District) session.load(District.class, 1);
        //获取三个街道
        Street  street1= (Street) session.load(Street.class, 2);
        Street  street2= (Street) session.load(Street.class, 3);
        Street  street3= (Street) session.load(Street.class, 4);
        session.delete(district);
        transaction.commit();
        /**
         *  Hibernate: update Street set districtId=null where districtId=?
            Hibernate: delete from Street where id=?
            Hibernate: delete from Street where id=?
            Hibernate: delete from Street where id=?
            Hibernate: delete from District where id=?
         */
    }
    
    
    
    /**
     * 针对于 多余的sql语句 解决办法！
     * 
     * 只需要一方来维护表之间的关系！
     * inverse属性：
     *   01.默认是false(由我维护！)
     *   02.inverse=true:这一方不维护关系！（不与数据库交互）
     *  
     *   
     *  不能都维护，也不能都 不维护！ 这个时候关键是谁来维护这个关系？
     *  双向的一对多！ 
     *  hibernate:规定多的一端来维护关系，那么必须在一的一方设置 inverse=true:
     */
    @Test
    public  void  test10(){
        //创建区县
        District district=new District(4, "区县4");
        //创建街道
        Street street1=new Street(5, "街道5");
        Street street2=new Street(6, "街道6");
        Street street3=new Street(7, "街道7");
        //给区县的街道赋值
        district.getStreets().add(street1);
        district.getStreets().add(street2);
        district.getStreets().add(street3);
        //保存区县
        session.save(district);   //发现 保存了 区县  但是 没有保存对应的街道！
        transaction.commit();
        /**
         * 
         * 发现  没有了 update语句！
         * Hibernate: select street_.id, street_.name as name1_, street_.districtId as districtId1_ from Street street_ where street_.id=?
            Hibernate: select street_.id, street_.name as name1_, street_.districtId as districtId1_ from Street street_ where street_.id=?
            Hibernate: select street_.id, street_.name as name1_, street_.districtId as districtId1_ from Street street_ where street_.id=?
            Hibernate: insert into District (name, id) values (?, ?)
            Hibernate: insert into Street (name, districtId, id) values (?, ?, ?)
            Hibernate: insert into Street (name, districtId, id) values (?, ?, ?)
            Hibernate: insert into Street (name, districtId, id) values (?, ?, ?)
         */
    }

2.

​ Hibernate中用注解配置一对多双向关联和多对一单向关联

Hibernate提供了Hibernate Annotations扩展包，使用注解完成映射。在Hibernate3.3之前，需单独下载注解开发包

配置持久化类

配置关联关系

下面我们先从多对一单向关联关系讲起，多对一单向关联就是在多的一方植入一的一方的主键作为外键，下面我们先进行初始配置，

在配置的过程中我们会遇到一个问题 就是无论用load还是get都不会出现延迟加载，那么我们应该如何设置为要延迟加载，这样做的好处是可以在用的时候才加载对应的信息，节约内存

hibernate中，延迟加载大致可以分为两类，一类是延迟属性加载，另一类是延迟关联实体加载。

**普通属性：**分两种情况，一种是集合属性，一种是非集合属性（如String、Integer…）

集合属性的延迟加载通过PersistentSet、 PersistentList、PersistentBag、PersistentMap、PersistentSortedMap、 PersistentSortedSet作为代理类来实现，代理类中保存了session以及owner属性，owner属性表示了集合属性所属的one 侧的实体。

非集合类属性的延迟加载相对比较复杂。仅通过@Basic(fetch = FetchType.LAZY)注解是无法实现延迟加载的。需要让实体实现FieldHandled接口，声明FieldHandler属性，通过拦截器 原理注入对应的FieldHandler属性，起到类似于上述代理类的作用，FieldHandler同样也保持了session，以及需要延迟加载的属 性。

我们发现对非集合属性即时设置了@Basic(fetch = FetchType.LAZY)仍无法实现延迟加载，可以看生成的sql语句

接下来 我们会对一对多单向关联进行测试，验证对集合类属性，是否可以起到延迟加载的功能

注意：不可以对有关联关系的属性设置@Transient

配置多对一的单向关联关系 示例

 1 package cn.happy.entity;
 2 
 3 import javax.persistence.Basic;
 4 import javax.persistence.Column;
 5 import javax.persistence.Entity;
 6 import javax.persistence.FetchType;
 7 import javax.persistence.GeneratedValue;
 8 import javax.persistence.GenerationType;
 9 import javax.persistence.Id;
10 import javax.persistence.JoinColumn;
11 import javax.persistence.ManyToOne;
12 import javax.persistence.SequenceGenerator;
13 import javax.persistence.Table;
14 import javax.persistence.Transient;
15 
16 @Entity
17 @Table(name = "EMP")
18 public class Emp {
19     @Id
20     @Column(name = "EMPNO")
21     @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "emp_num")
22     @SequenceGenerator(name = "emp_num", sequenceName = "emp_num_id", allocationSize = 1, initialValue = 1)
23     private Integer empNo;
24 
25     @Column(name = "EMPNAME")
26     private String empName;
27     
28     @ManyToOne()
29     @JoinColumn(name = "DEPTNO")
30     /*@Basic(fetch=FetchType.LAZY)*/
31     private Dept dept;
32 
33     
34     public Emp() {
35         super();
36     }
37 
38     public Emp(Integer empNo, String empName) {
39         super();
40         this.empNo = empNo;
41         this.empName = empName;
42     }
43 
44     public Integer getEmpNo() {
45         return empNo;
46     }
47 
48     public void setEmpNo(Integer empNo) {
49         this.empNo = empNo;
50     }
51 
52     public String getEmpName() {
53         return empName;
54     }
55 
56     public void setEmpName(String empName) {
57         this.empName = empName;
58     }
59 
60     public Dept getDept() {
61         return dept;
62     }
63 
64     public void setDept(Dept dept) {
65         this.dept = dept;
66     }
67 }

 1 package cn.happy.entity;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 import javax.persistence.CascadeType;
 7 import javax.persistence.Column;
 8 import javax.persistence.Entity;
 9 import javax.persistence.GeneratedValue;
10 import javax.persistence.GenerationType;
11 import javax.persistence.Id;
12 import javax.persistence.JoinColumn;
13 import javax.persistence.OneToMany;
14 import javax.persistence.SequenceGenerator;
15 import javax.persistence.Table;
16 import javax.persistence.Transient;
17 
18 import org.hibernate.annotations.Cascade;
19 
20 @Entity
21 @Table(name = "DEPT")
22 public class Dept {
23     @Id
24     @Column(name = "DEPTNO")
25     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="dept_num")
26     @SequenceGenerator(name="dept_num",sequenceName="dept_num_no",allocationSize=1,initialValue=1)
27     private Integer deptNo;
28 
29     @Column(name = "DEPTNAME")
30     private String deptName;
31 
32 
33     public Integer getDeptNo() {
34         return deptNo;
35     }
36 
37     public void setDeptNo(Integer deptNo) {
38         this.deptNo = deptNo;
39     }
40 
41     public String getDeptName() {
42         return deptName;
43     }
44 
45     public void setDeptName(String deptName) {
46         this.deptName = deptName;
47     }
48 }

 1 /**
 2      * 注解测试多对一映射   员工表（多）对应部门表（一）的映射,即只在员工表中植入部门表的信息
 3      * */
 4     @Test
 5     public void manytooneSingle(){
 6         
 7         /**
 8          * 查询操作
 9          * **/
10         /*SessionFactory sf=new AnnotationConfiguration().configure().buildSessionFactory();
11         Session session = sf.openSession();
12         
13         Emp emp=(Emp)session.load(Emp.class, 4);
14         
15         System.out.println(emp.getEmpName()+"\t"+emp.getDept().getDeptName());*/
16         
17         /**
18          * 添加操作
19          * **/
20         SessionFactory sf=new AnnotationConfiguration().configure().buildSessionFactory();
21         Session session = sf.openSession();
22         Transaction tx = session.beginTransaction();
23         Dept dept = (Dept)session.load(Dept.class, 3);
24         
25         Emp emp=new Emp();
26         emp.setEmpName("户梦艳");
27         emp.setEmpNo(001);
28         emp.setDept(dept);
29         
30         Emp emp2=new Emp();
31         emp2.setEmpName("户梦艳2");
32         emp2.setEmpNo(002);
33         emp2.setDept(dept);
34         
35         session.save(emp);
36         session.save(emp2);
37         tx.commit();
38         session.close();
39         
40         
41     }

一对多双单向配置

 1 package cn.happy.entity;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 import javax.persistence.CascadeType;
 7 import javax.persistence.Column;
 8 import javax.persistence.Entity;
 9 import javax.persistence.GeneratedValue;
10 import javax.persistence.GenerationType;
11 import javax.persistence.Id;
12 import javax.persistence.JoinColumn;
13 import javax.persistence.OneToMany;
14 import javax.persistence.SequenceGenerator;
15 import javax.persistence.Table;
16 import javax.persistence.Transient;
17 
18 
19 @Entity
20 @Table(name="Dept")
21 public class Dept {
22     @Id    
23     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="dept_num")
24     @SequenceGenerator(name="dept_num",sequenceName="dept_num_no",allocationSize=1,initialValue=1)
25     private Integer deptNo;
26     @Column
27     private String deptName;
28     
29     
30     @OneToMany(cascade={CascadeType.ALL})
31     @JoinColumn(name="deptno")
32     private Set<Emp> emps=new HashSet<Emp>();
33 
34     public Set<Emp> getEmps() {
35         return emps;
36     }
37 
38     public void setEmps(Set<Emp> emps) {
39         this.emps = emps;
40     }
41 
42     public Integer getDeptNo() {
43         return deptNo;
44     }
45 
46     public void setDeptNo(Integer deptNo) {
47         this.deptNo = deptNo;
48     }
49 
50     public String getDeptName() {
51         return deptName;
52     }
53 
54     public void setDeptName(String deptName) {
55         this.deptName = deptName;
56     }
57 }

 1 package cn.happy.entity;
 2 
 3 import javax.persistence.Basic;
 4 import javax.persistence.Column;
 5 import javax.persistence.Entity;
 6 import javax.persistence.FetchType;
 7 import javax.persistence.GeneratedValue;
 8 import javax.persistence.GenerationType;
 9 import javax.persistence.Id;
10 import javax.persistence.JoinColumn;
11 import javax.persistence.ManyToOne;
12 import javax.persistence.SequenceGenerator;
13 import javax.persistence.Table;
14 import javax.persistence.Transient;
15 
16 import org.hibernate.bytecode.javassist.FieldHandled;
17 import org.hibernate.bytecode.javassist.FieldHandler;
18 
19 
20 @Entity
21 @Table(name = "EMP")
22 public class Emp {
23     
24     
25     
26     @Id
27     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="emp_num")
28     @SequenceGenerator(name="emp_num",sequenceName="emp_num_no",allocationSize=1,initialValue=9)
29     private Integer empNo;
30 
31     @Column
32     private String empName;
33     
34    
35 //    @ManyToOne
36 //    @JoinColumn(name="deptno")
37 //    @Basic(fetch=FetchType.LAZY)
38 //    private Dept dept;
39 //    
40 //    public Dept getDept() {
41 //        return dept;
42 //    }
43 //
44 //    public void setDept(Dept dept) {
45 //        this.dept = dept;
46 //    }
47 
48     public Emp() {
49         super();
50     }
51 
52     public Emp(Integer empNo, String empName) {
53         super();
54         this.empNo = empNo;
55         this.empName = empName;
56     }
57 
58     public Integer getEmpNo() {
59         return empNo;
60     }
61 
62     public void setEmpNo(Integer empNo) {
63         this.empNo = empNo;
64     }
65 
66     public String getEmpName() {
67         return empName;
68     }
69 
70     public void setEmpName(String empName) {
71         this.empName = empName;
72     }
73     
74 
75 }

 1 /**
 2      * 测试一对多单向添加操作
 3      * */
 4     @Test
 5     public void insertOneToManySingle(){
 6         Emp emp=new Emp();
 7         emp.setEmpName("李小鹏");
 8         
 9         Emp emp2=new Emp();
10         emp2.setEmpName("王想想");
11         
12         Dept dept=new Dept();
13         dept.setDeptName("教务部");
14         //设置级联操作
15         dept.getEmps().add(emp);
16         dept.getEmps().add(emp2);
17         
18         session.save(dept);
19         tx.commit();
20         System.out.println("insert ok");
21         
22     }

 1     /**
 2      * 测试一对多单向查询操作
 3      * */
 4     @Test
 5     public void selectOneToManySingle(){
 6         Dept dept = (Dept)session.load(Dept.class, 1);
 7         System.out.println("======================");
 8         System.out.println("部门名称:"+dept.getDeptName());
 9         System.out.println("=======================");
10         //体现了延迟加载
11         for (Emp emp : dept.getEmps()) {
12             System.out.println("雇员名称："+emp.getEmpName());
13         }
14         //Emp emp = (Emp)session.load(Emp.class, 1);
15         
16         
17     }

一对多双向配置

 1 package cn.happy.entity;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 import javax.persistence.CascadeType;
 7 import javax.persistence.Column;
 8 import javax.persistence.Entity;
 9 import javax.persistence.GeneratedValue;
10 import javax.persistence.GenerationType;
11 import javax.persistence.Id;
12 import javax.persistence.JoinColumn;
13 import javax.persistence.OneToMany;
14 import javax.persistence.SequenceGenerator;
15 import javax.persistence.Table;
16 import javax.persistence.Transient;
17 
18 
19 @Entity
20 @Table(name="Dept")
21 public class Dept {
22     @Id    
23     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="dept_num")
24     @SequenceGenerator(name="dept_num",sequenceName="dept_num_no",allocationSize=1,initialValue=1)
25     private Integer deptNo;
26     @Column
27     private String deptName;
28     
29     
30     @OneToMany(mappedBy="dept",cascade={CascadeType.ALL})
31    
32     private Set<Emp> emps=new HashSet<Emp>();
33 
34     public Set<Emp> getEmps() {
35         return emps;
36     }
37 
38     public void setEmps(Set<Emp> emps) {
39         this.emps = emps;
40     }
41 
42     public Integer getDeptNo() {
43         return deptNo;
44     }
45 
46     public void setDeptNo(Integer deptNo) {
47         this.deptNo = deptNo;
48     }
49 
50     public String getDeptName() {
51         return deptName;
52     }
53 
54     public void setDeptName(String deptName) {
55         this.deptName = deptName;
56     }
57 }

 1 package cn.happy.entity;
 2 
 3 import javax.persistence.Basic;
 4 import javax.persistence.Column;
 5 import javax.persistence.Entity;
 6 import javax.persistence.FetchType;
 7 import javax.persistence.GeneratedValue;
 8 import javax.persistence.GenerationType;
 9 import javax.persistence.Id;
10 import javax.persistence.JoinColumn;
11 import javax.persistence.ManyToOne;
12 import javax.persistence.SequenceGenerator;
13 import javax.persistence.Table;
14 import javax.persistence.Transient;
15 
16 import org.hibernate.bytecode.javassist.FieldHandled;
17 import org.hibernate.bytecode.javassist.FieldHandler;
18 
19 
20 @Entity
21 @Table(name = "EMP")
22 public class Emp {
23     
24     
25     
26     @Id
27     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="emp_num")
28     @SequenceGenerator(name="emp_num",sequenceName="emp_num_no",allocationSize=1,initialValue=9)
29     private Integer empNo;
30 
31     @Column
32     private String empName;
33     
34    
35     @ManyToOne
36     @JoinColumn(name="deptno")
37     @Basic(fetch=FetchType.LAZY)
38     private Dept dept;
39     
40     public Dept getDept() {
41         return dept;
42     }
43 
44     public void setDept(Dept dept) {
45         this.dept = dept;
46     }
47 
48     public Emp() {
49         super();
50     }
51 
52     public Emp(Integer empNo, String empName) {
53         super();
54         this.empNo = empNo;
55         this.empName = empName;
56     }
57 
58     public Integer getEmpNo() {
59         return empNo;
60     }
61 
62     public void setEmpNo(Integer empNo) {
63         this.empNo = empNo;
64     }
65 
66     public String getEmpName() {
67         return empName;
68     }
69 
70     public void setEmpName(String empName) {
71         this.empName = empName;
72     }
73     
74 
75 }

 1     /**
 2      * 双向一对多的添加操作
 3      * */
 4     @Test 
 5     public void oneToManyDouble(){
 6         Dept dept=new Dept();
 7         dept.setDeptName("财务部");
 8         
 9         Emp emp=new Emp();
10         emp.setEmpName("邹乐");
11         emp.setDept(dept);
12         
13         Emp emp2=new Emp();
14         emp2.setEmpName("范子阳");
15         emp2.setDept(dept);
16         
17         
18         dept.getEmps().add(emp);
19         dept.getEmps().add(emp2);
20         
21         session.save(dept);
22         tx.commit();
23     }
24     

 1 /**
 2      * 双向一对多的查询操作
 3      * */
 4     @Test 
 5     public void selectOneToManyDouble(){
 6         
 7         Dept dept = (Dept)session.load(Dept.class, 1);
 8         System.out.println("部门名称："+dept.getDeptName());
 9         for (Emp emp : dept.getEmps()) {
10             System.out.println("职工姓名："+emp.getEmpName());
11         }
12         
13         System.out.println("==================================================");
14         
15         Emp emp = (Emp)session.load(Emp.class, 1);
16         System.out.println("职工姓名："+emp.getEmpName()+"\t部门名称："+emp.getDept().getDeptName());
17     }
18     

7.struts.2核心配置

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <!--过滤器的引用-->
  <filter>
        <filter-name>Myfilter</filter-name>
        <filter-class>com.zhiwen.filter.Myfilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>Myfilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
      <!--strtus2的引用-->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>	

8.session的解耦与耦合

8.1解耦

  Map<String, Object> session1 = ActionContext.getContext().getSession();

8.2耦合

   HttpSession session = ServletActionContext.getRequest().getSession();
		 session.setAttribute("employees", queryppostion.getNameCn());

   System.out.println("==================================================");

14
15 Emp emp = (Emp)session.load(Emp.class, 1);
16 System.out.println(“职工姓名：”+emp.getEmpName()+"\t部门名称："+emp.getDept().getDeptName());
17 }
18

## 7.struts.2核心配置      

```xml
<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <!--过滤器的引用-->
  <filter>
        <filter-name>Myfilter</filter-name>
        <filter-class>com.zhiwen.filter.Myfilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>Myfilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
      <!--strtus2的引用-->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>	

8.session的解耦与耦合

8.1解耦

  Map<String, Object> session1 = ActionContext.getContext().getSession();

8.2耦合

   HttpSession session = ServletActionContext.getRequest().getSession();
		 session.setAttribute("employees", queryppostion.getNameCn());