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>

　　①管理对象,所有对象都是通过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>

　　③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();
        }
    }
}

　　③高级部分:

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

　　　　使用连接池:在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整合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>