ssh框架的总结

一、spring:是基础,可以管理对象,也可以通过关键对象管理另一个框架。但是首先应该明确spring并不是只能应用于web方面,而是可以应用在一般的java项目中。只是如果在web环境下使用需要在web.xml中进行注册(启动IOC容器的servletContextListener)。还有就是获取方式稍有不同。

  <!-- 下面是有关spring在web中启动的配置,是spring提供的listener -->
     <!-- 启动IOC容器的servletContextListener -->
      <listener>
         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
       </listener>
       <!-- 添加spring配置文件名称和位置 -->
       <context-param>
             <param-name>contextConfigLocation</param-name>
         <param-value>classpath:applicationContext.xml</param-value>
       </context-param>

在web.xml注册spring启动监听器

　　①管理对象,所有对象都是通过spring配置,需要时通过其产生(IOC)。是解除紧耦合的第一步。

　　　　通过spring管理的对象需要在配置文件中注册或者通过注释配置,就是一个<bean>,还可以为 构造函数参数/属性 注入值

　　②AOP面向切面编程的实现,我的简单理解就是业务层面的解耦。

　　　　AOP同样可以通过配置和注释实现。　

 <?xml version="1.0" encoding="UTF-8"?>
 <beans
     xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:p="http://www.springframework.org/schema/p"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.1.xsd">
     <!-- 下面一句是开启spring的注释配置方式,需要在beans的属性中添加xmlns:context的命名空间
         实质上是开启了注解的解析处理器,有四种
     -->
     <context:annotation-config/>

     <!-- 注意:每个bean默认情况下都是单例对象 -->
     <!-- 配置bean,id在获取时使用,class对应实际的javabean类-->
     <bean id="stu" class="com.dqxst.domain.Stu">
         <!--
             1、 下面是设置构造器参数,按照顺序,对应可以接受这些值的构造器来构造对象,
             例如下面的设置就是对应(String,int)参数的构造器,顺序不能乱
             2、如果参数是自定义对象,则应该使用ref而非value,值为已经声明的bean的id
         -->
         <constructor-arg value="sfl"/>
         <constructor-arg value="15"/>
         <constructor-arg ref="helloWorld" />

         <!--
             下面是为javabean属性赋值,相当于使用set(),也称属性注入
             当然,这种操作是在创建对象之后的,也就是在上面的构造器方法之后使用
             同样,如果注入的是一个对象,使用的是ref
          -->
         <property name="name" value="test"></property>
         <property name="study" ref="work"></property>
         <!-- 声明一个内部类 -->
         <property name="home">
             <bean class="com.dqxst.domain.Home">
                 <property name="father" value="ssk"></property>
                 <property name="mother" value="wsp"></property>
             </bean>
         </property>
     </bean>

     <bean id="helloWorld" class="com.dqxst.domain.HelloWorld"></bean>

     <!-- factory-method属性用于没有公开构造器的类创建对象,通常用于单例模式下的对象创建
         称为静态工厂方法配置bean
     -->
     <bean id="classroom" class="com.dqxst.domain.Classroom"
         factory-method="getInstance"/>

     <!-- scope属性用于确定bean的作用域,即在那个范围中是唯一的 -->
     <bean id="work" class="com.dqxst.domain.Work" scope="prototype" />

     <bean id="collage" class="com.dqxst.domain.Collage"
         factory-method="getInstance" />

     <!-- 下面这个bean是用于AOP的 -->
     <bean id="classes" class="com.dqxst.aop.Classes" />
     <bean id="classes2" class="com.dqxst.aop.Classes2" />
         <!-- 下面是AOP的一些配置,注意都是在一个节点之内的 -->
     <aop:config>
         <!-- 定义一个切面 -->
         <aop:aspect ref="classes">
             <!-- 定义一个通知,在内部声明切点,也可以引用一个外部声明的切点 -->
             <aop:before pointcut="execution(* com.dqxst.domain.Stu.study(..))"
                 method="stand"/>
             <!-- 这个通知引用外部切点声明,注意多个同一点的切点按声明顺序执行,例如这里的两个前者通知 -->
             <aop:before pointcut-ref="pointcut"
                 method="sayHi"/>
             <aop:after-throwing pointcut-ref="pointcut"
                 method="delayed"/>
             <aop:after pointcut-ref="pointcut"
                 method="sayBye"/>
             <!-- 外部切点声明 -->
             <aop:pointcut id="pointcut"
                 expression="execution(* com.dqxst.domain.Stu.study(..))"/>
         </aop:aspect>
         <aop:aspect ref="classes2">
             <aop:pointcut expression="execution(* com.dqxst.domain.Stu.nowStudy(..))"
                 id="pcut"/>
             <aop:around pointcut-ref="pcut" method="onClass"/>
         </aop:aspect>
     </aop:config>
 </beans>

spring配置文件

　　③springmvc:基于spring的mvc框架,优点是和spring结合紧密,不需多余配置。

参考：http://blog.csdn.net/lishuangzhe7047/article/details/20740209

http://www.blogjava.net/stevenjohn/archive/2012/08/20/385846.html

二、strut2:是用filter作为控制器的MVC框架,配置环境分三步：

　　1、添加jar包,2、添加strut.xml配置文件,3、在web.xml中进行配置(配置strut的主要过滤器filter)

　　需要注意的是strut配置文件默认不提示,联网情况下可以自动下载dtd约束文件,但是也可以手动配置本地约束文件

　　struts2负责C(controller)的部分:主要负责将url/form中的数据发送到指定的url对应的Action类进行处理,具体的处理过程如下:

　　1、首先,Struts2通过属性/模型驱动来自动封装数据为实体对象,节省了很多的重复操作,但是这也对实体属性命名和表单name属性命名有一些对应要求;

　　2、这些Action类就是和servlet执行相同的工作,也可以获取域对象(即web资源)进行操作。

　　3、最后定位到JSP页面进行输出。

　　①struct2数据传递的方式:值栈,可以通过struct2标签和OGNL表达式进行读取,这三个是struct2的重要基础

参考：http://blog.knowsky.com/188302.htm

http://blog.csdn.net/a549324766/article/details/7206876

http://blog.knowsky.com/194419.htm

三、hibernate:经典的关系对象映射框架,就是将数据库中关系型的数据转换成java中的对象型数据。主要有以下几点:

　　①编写pojo类,配置映射关系。重要

　　②hibernate使用:

　　　　①首先获取SessionFactory对象,然后得到Session对象。通过Session对象进行增删查改实际操作。注意:sessionFactory是线程安全的,但是Session线程不安全,由于servlet的单例特点,可能引发线程问题,所以需要注意。并且在Session管理中的对象有不同的状态还可以转化。和jdcb一样,基础操作比较复杂,可以使用工具类简化使用。

参考：http://lialiks.bokee.com/586567.html

http://blog.csdn.net/shrek_xu/article/details/740991

　　　　②HQL,面向对象查询,类似sql。多表查询差别大。真实使用的sql语句是hibernate通过HQL和映射文件自动生成的。缺点是不利于优化。

 import hibernate_g_query.domain.Department;
 import hibernate_g_query.domain.Employee;

 import java.util.Arrays;
 import java.util.List;

 import org.hibernate.Criteria;
 import org.hibernate.Session;
 import org.hibernate.Transaction;
 import org.hibernate.criterion.Restrictions;
 import org.junit.Test;

 import com.dqxst.dao.DaoUtils;

 public class Dao {
     @Test
     public void save() {
         Session session = DaoUtils.openSession();
         Transaction tx = null;
         try {
             tx = session.beginTransaction();

             for (int i = 0; i < 10; i++) {
                 Department department = new Department();
                 department.setName("研发部" + i);
                 session.save(department);
             }

             for (int i = 0; i < 20; i++) {
                 Employee employee = new Employee();
                 employee.setName("test" + i);
                 session.save(employee);
             }

             tx.commit();
         } catch (Exception e) {
             tx.rollback();
             throw e;
         } finally {
         }
     }

     // 练习hql查询语句
     @Test
     public void hql() {
         Session session = DaoUtils.openSession();
         Transaction tx = null;
         try {
             tx = session.beginTransaction();
             /*
              * 一般特点: 1、和sql语句相似,但是移植性好 2、hql查询的是对象及其属性,即from后的是对象;
              * 3、涉及到对象的部分需要区分大小写,其余部分不用。如果类名是唯一的可以直接使用, 否则需要使用全限定名
              */
             String hql;
             // 1、简单查询,不使用select,可以使用别名,也可以省略as,没有限定条件查询所有
             hql = "FROM Employee e";

             // 2、使用过滤条件,即where语句
             hql = "FROM Employee e WHERE e.id<10";

             // 3、使用order by排序
             hql = "FROM Employee e WHERE e.id<10 ORDER BY id DESC";

             /*
              * 4、指定select子句, 1、不使用select时返回值是对象的List集合 2、查询单列:
              * 3、查询多列:返回的是集合的元素类型是Object数组 ！！！ 但是可以使用new将这些列封装为对象,需要有对应的构造函数
              */
             hql = "SELECT e.name FROM Employee e";

             hql = "SELECT e.id,e.name FROM Employee e";
             // 对应的构造函数就是以该两列为参数的构造函数
             hql = "SELECT new Employee(e.id,e.name) FROM Employee e";

             /*
              * 5、执行查询,获取结果 1、获取查询对象 2、获取结果集
              */
             // Query query=session.createQuery(hql);
             // //hibernate的分页
             // query.setFirstResult(0);
             // query.setMaxResults(10);
             // List<?> list=query.list();

             // 6、hibernate支持方法链操作
             List<?> list = session.createQuery(hql)//
                     .setFirstResult(0)//
                     .setMaxResults(10)//
                     .list();

             for (Object obj : list) {
                 if (obj.getClass().isArray()) {
                     System.out.println(Arrays.toString((Object[]) obj));
                 } else {
                     System.out.println(obj);
                 }
             }
             tx.commit();
         } catch (Exception e) {
             tx.rollback();
             throw e;
         } finally {
             session.close();
         }
     }

     @Test
     public void hql2() {
         Session session = DaoUtils.openSession();
         Transaction tx = null;
         try {
             tx = session.beginTransaction();

             String hql;

             /* 1，聚集函数:count() min() max() sum() avg()
              * count()返回结果为Long型,其余返回为查询的属性的类型。使用Number类型最好
              */
             hql="SELECT COUNT(*) FROM Employee";
             Number result=(Number) session.createQuery(hql).uniqueResult();
             System.out.println(result);

             // 2，分组 group by和having,一些子句可以使用列别名,但是不推荐使用
             hql="SELECT e.name,COUNT(*) FROM Employee e GROUP BY e.name "
                     + "HAVING COUNT(*)>6";

             /* 3，连接查询 / HQL是面向对象的查询
              * 默认是inner join内连接,还可以使用left (out)/right (out)进行查询
              * 但是hql还有更简单的方式：可以像查询属性一样进行连接查询,内部会进行转换
              */
             //hql="SELECT e.id,e.name,d.name FROM Employee e JOIN e.department d";
             hql="SELECT e.id,e.name,e.department.name FROM Employee e";

             // 4，查询时使用参数:和jdbc中类似,防止sql注入
             //     >>方式一：使用'?'占位
 //            hql="FROM Employee WHERE id BETWEEN ? AND ?";
 //            List<?> list=session.createQuery(hql)//
 //                    .setParameter(0, 5)//
 //                    .setParameter(1, 15)//
 //                    .list();
             //     >>方式二：使用变量名
 //            hql="FROM Employee WHERE id BETWEEN :idMin AND :idMax";
 //            List<?> list=session.createQuery(hql)//
 //                    .setParameter("idMin", 5)//
 //                    .setParameter("idMax", 15)//
 //                    .list();
             //    >>当参数不确定时可以使用集合传参
 //            hql="FROM Employee WHERE id IN (:ids)";
 //            List<?> list=session.createQuery(hql)//
 //                    .setParameterList("ids", new Object[]{1,2,5,7})//
 //                    .list();

             /* 5，使用命名查询:就是将查询语句写到配置文件中而不是硬编码到程序中,
              * 通过名字来查找sql语句,并生成Query对象,
              * 该查询语句通常写到该实体的映射文件中
              */
             List<?> list=session.getNamedQuery("queryByIdRange")//
                     .setParameter("idMin", 5)//
                     .setParameter("idMax", 15)//
                     .list();

             /* 6，update与delete，不会通知Session缓存,也就是通过session获取时不能获取最新值
              * 所以:在update或delete后，需要refresh(obj)一下以获取最新的状态
              */
             hql="UPDATE Employee e SET e.name=? WHERE e.id>15";
             result=session.createQuery(hql)//
                     .setParameter(0, "asd")//
                     .executeUpdate();       //执行更新语句,返回受影响行数
             session.refresh(list);
             System.out.println(result);

 //            List<?> list = session.createQuery(hql)//
 //                    .list();

             for (Object obj : list) {
                 if (obj.getClass().isArray()) {
                     System.out.println(Arrays.toString((Object[]) obj));
                 } else {
                     System.out.println(obj);
                 }
             }
             tx.commit();
         } catch (Exception e) {
             tx.rollback();
             throw e;
         } finally {
             session.close();
         }
     }

     @Test
     public void qbc(){
         Session session = DaoUtils.openSession();
         Transaction tx = null;
         try {
             tx = session.beginTransaction();

             //创建对象
             Criteria criteria=session.createCriteria(Employee.class);

             //添加过滤条件
             criteria.add(Restrictions.ge("id", 5));
             criteria.add(Restrictions.le("id", 10));
             //添加排序条件

             //执行查询,获取结果集
             List<?> list=criteria.list();
             for (Object obj : list) {
                 if (obj.getClass().isArray()) {
                     System.out.println(Arrays.toString((Object[]) obj));
                 } else {
                     System.out.println(obj);
                 }
             }
             tx.commit();
         } catch (Exception e) {
             tx.rollback();
             throw e;
         } finally {
             session.close();
         }
     }
 }

HQL使用

　　③高级部分:

　　　　懒加载:就是关联查询时可以在使用之前在查询而不是直接查询

　　　　使用连接池:在hibernate配置文件即可配置,但是如果和spring配合使用则在spring中进行配置。

　　　　缓存(一级/二级)  参考：http://www.cnblogs.com/shanmu/p/3598509.html

四、框架整合,所谓的整合就是使用spring关联struct2和hibernate框架,然后使用tomcat生成spring。

　　①spring整合hibernate,主要是两个:管理sessionFactory,管理事务

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:p="http://www.springframework.org/schema/p"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.1.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd">

     <context:component-scan base-package="com.dqxst" />
     <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>   

     <!-- 导入资源文件 -->
     <context:property-placeholder location="classpath:db.properties"/>

     <!-- 配置C3P0资源,值使用的是properties中的值 -->
     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
         <property name="driverClass" value="${driverClass}"></property>
         <property name="jdbcUrl" value="${jdbcUrl}"></property>
         <property name="user" value="${user}"></property>
         <property name="password" value="${password}"></property>
         <property name="initialPoolSize" value="${initPoolSize}"></property>
         <property name="maxPoolSize" value="${maxPoolSize}"></property>
     </bean>

     <!-- 配置hibernate的SessionFactory实例,其实是spring中的LocalSessionFactoryBean -->
     <bean id="sessionFactory"
         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

         <!-- 引入数据源 -->
         <property name="dataSource" ref="dataSource"></property>

         <!-- 引入hibernate配置文件,最好是在该配置文件中进行配置 -->
         <property name="configLocation"
             value="file:src/hibernate.cfg.xml">
         </property>
             <!-- 在spring中配置hibernate属性 -->
         <property name="hibernateProperties">
             <props>
                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
             </props>
         </property>

         <!-- 引入映射文件 -->
         <property name="mappingLocations" value="classpath:com/dqxst/domain/*.hbm.xml"></property>
     </bean>

     <bean id="transactionManager"
         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
         <property name="sessionFactory" ref="sessionFactory" />
     </bean>
     <tx:annotation-driven transaction-manager="transactionManager" />
 </beans>

spring整合hibernate配置

　　②spring整合struct2,主要体现在通过spring来管理struct2使用的action对象,所以不需要过多的配置。但是struct2是通过拦截器链实现的,所以需要在web.xml中配置struct2使用的主过滤器,注意要在spring之后配置。

   <!-- 配置Struts2的主过滤器 -->
   <filter>
     <filter-name>struts2</filter-name>
     <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
   </filter>
   <filter-mapping>
     <filter-name>struts2</filter-name>
     <url-pattern>/*</url-pattern>
   </filter-mapping>

配置struct2主过滤器