SpingMVC流程图

Struts的请求流程

springmvc的流程

0.struts2       MVC框架  Controller
  Hibernate     持久化框架   Model
  spring        项目管理框架   为javaEE开发提供更好的解决方案
======================================================================================
1.spring:工厂,容器
        :创建项目中的所有模块(组件),并持有管理所有的组件.
        :spring的所有功能实现,都架设在工厂(容器)的支持下.
======================================================================================
2.spring工厂搭建:
  2.1 导包:
  2.2 配置文件:告知spring需要生产的组件.
       *位置:任意
       *名称:任意   applicationContext.xml    beans.xml
        <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
                                   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
            
            <!-- 告知spring生产如下的组件 -->
            <bean id="ud47" class="com.c47.dao.UserDAOImpl"></bean>
            <bean id="us47" class="com.c47.serivce.UserServiceImpl"></bean>
        </beans>
  2.3 api:启动工厂:
        ApplicationContext
        ClassPathXmlApplicationContext
        //启动工厂:指定配置文件位置
        ApplicationContext context=new ClassPathXmlApplicationContext("com/c47/config/applicationContext.xml");
        //从工厂中获取bean
        UserDAO ud=(UserDAO)context.getBean("ud47");
        UserService us=(UserService)context.getBean("us47");
=====================================================================================
3.IOC Inverse Of Controll  控制反转
  :将属性的赋值权有静态代码中 反转 到配置文件中
  :将具有依赖关系的双方的耦合打散.提高项目的可维护性.
  :在配置文件中为属性赋值:DI  Dependency Injection  依赖注入
=====================================================================================
4.set注入:通过set方法,将属性值存入.
    <!-- jdk8中基本类型+String -->
    <property name="id" value="1"></property>
    <property name="name" value="c47"></property>
    <property name="gender" value="true"></property>
    <!-- List/数组 -->
    <property name="list47">
        <list>
            <value>1</value>
            <value>c47</value>
            <value>true</value>
            <ref bean="us47"/>
        </list>
    </property>
    <!-- Map -->
    <property name="map47">
        <map>
            <entry key="name" value="lichangpu"></entry>
            <entry key="age" value="18"></entry>
            <entry key="gender" value="true"></entry>
            <entry key="us47" value-ref="us47"></entry>
        </map>
    </property>
    <!-- properties -->
    <property name="props">
        <props>
            <prop key="url">jdbc:oracle:xxx</prop>
            <prop key="username">hr</prop>
        </props>
    </property>
=====================================================================================
5.构造注入:通过构造方法,为属性赋值
    <!-- 第一个参数,类型为Integer -->
    <constructor-arg index="0" type="java.lang.Integer" value="47"></constructor-arg>
    <constructor-arg index="1" type="java.lang.String" value="c47"></constructor-arg>
    <constructor-arg index="2" type="java.lang.Boolean" value="true"></constructor-arg>
    弊端:不够灵活
        :用于构造不提供空参构造的组件.
=====================================================================================
6.自动注入
    <!--
        autowire:自动装载
        byType:将工厂中与目标组件的属性同类型的bean,赋值给对应属性
        byName:将工厂中与目标组件的属性同名的bean,赋值给对应属性
     -->
    <bean id="ioc49" class="com.c47.IOC.test.TestIOC3" autowire="byName"></bean>
=====================================================================================
7.spring对于bean的生产原理:
    反射+空参构造:
    String path="com.c47.dao.UserDAOImpl";
    Class claz=Class.forName(path);
    Object obj=claz.newInstance();//调用空参构造
    例外:当使用了构造注入时,就不会选取空参构造,而是调用配置中指定的构造方法.
=====================================================================================
8.bean的生命周期:
  *bean的构建时刻:spring工厂启动时,所有的单例的bean随之创建
  *bean的销毁时刻:spring工厂关闭时,所有bean随之销毁.
  *细节:bean的生命历程(了解)
    构造-->set-->init-->destroy
=====================================================================================
9.bean的创建模式
  *singleton:单例    全局唯一  (默认)
  *prototype:非单例  全局不唯一
  <bean id="c47" class="xx"/> 单例
  <bean id="userAction47" class="xxxx" scope="singleton"> 单例
  <bean id="userAction47" class="xxxx" scope="prototype"> 非单例
  *单例:无论使用(getBean()/用于注入)多少次,都只有一个对象
  *非单例:每使用一次,都要创建一个新的对象.
  *细节:
       在工厂启动时,非单例的bean不会随之创建.而是在被使用时才创建.
=====================================================================================
1.复杂对象:创建过程复杂.不能直接new.
          :FactoryBean==构建复杂对象
=====================================================================================
2.FactoryBean 工厂bean使用流程:
  2.1 定制FactoryBean
        implements FactoryBean<SessionFactory>{
            /**
             * 主体逻辑:定制复杂对象的创建流程
             */
            public SessionFactory getObject() throws Exception {
                ....
            }
            /**
             * 返回复杂对象的类对象
             */
            public Class getObjectType() {
                return SessionFactory.class;
            }
            /**
             * 定制复杂对象的创建模式:
             * return true;单例
             * return false;非单例
             */
            public boolean isSingleton() {
                return true;
            }
        }
  2.2 配置
        <!-- 声明工厂Bean -->
        <bean id="sessionFactory47" class="com.c47.factory_bean.MySessionFactory"></bean>
  2.3 使用:
        *当从工厂中获取bean时,如果此bean是FactoryBean,则返回给用户的并不是bean本身
         的对象.而是去回调此bean中的getObject(),返回此bean中getObject()方法的返回值.
====================================================================================
3.spring 初步的整合hibernate
  *将sessionfactory纳入工厂
  *将DAO,Service 纳入工厂
  *并通过IOC满足DAO和Service的依赖
====================================================================================
4.类型转换器:注入过程,如果双方的类型不匹配,则需要类型转换.
            :String-->数字,布尔 自动完成
    4.1 定制转换器类:
        extends PropertyEditorSupport{
            /**
             * <bean>
             *       <property name="birth" value="2015-12-11">
             * </bean>
             * 转换器的主体逻辑:完成数据格式转换
             * param:text  要转换的值(2015-12-11)
             * 此方法,会在spring需要类型转换时被spring回调
             * setAsText("2015-12-11");
             * getValue();
             */
            @Override
            public void setAsText(String text) throws IllegalArgumentException {
                SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd");
                try {
                    Date date=format.parse(text);
                    //将转换好的数据,交还spring
                    //将转换好的数据,存入父类的成员变量中,spring会回调父类的getValue(),将值取走.
                    this.setValue(date);
                } catch (ParseException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    4.2 配置:
           *声明类型转换器:
            <bean id="dateEditor47" class="com.c47.property_editor.MyPropertyEditor"></bean>
           *注册:
            <!-- 告知spring
                 CustomEditorConfigurer:统一管理所有转换器的入口
             -->
            <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
                <!-- 注册自定义的类型转换器
                     告知spring此转换器可以完成string到Date的转换
                 -->
                <property name="customEditors">
                    <map>
                        <entry key="java.util.Date" value-ref="dateEditor47"></entry>
                    </map>
                </property>
            </bean>
           *使用:
            <!-- 转换器测试 -->
            <bean id="user47" class="com.c47.entity.User">
                <property name="birth" value="2015-12-11 11:51:47"></property>
            </bean>
    *细节:如果是日期数据的注入,可以不定制转换器,spring默认的日期格式:
         :yyyy/MM/dd HH:mm:ss
====================================================================================
*补充:spring对于hiberante更新的支持:
    //User{id,name,age,Set<order> orders}
    //user{id,name,age,null}
    //user2{id,name,age,orders}
    public void updateUser(User user) {
        Session session=factory.getCurrentSession();
        User user2=(User)session.get(User.class, user.getId());
        //将user的属性值,赋值给user2中的同名属性.
        //技巧:在set方法中添加判断,过滤null
        BeanUtils.copyProperties(user, user2);
        session.update(user2);
    }

0.业务层:冗余:在业务中有大量的重复的逻辑散布在大量的业务方法,导致极大的冗余.
             :对于项目的开发,和后期的维护,都是极大的隐患.
        :耦合:在业务中有两类逻辑[核心业务],[额外功能],耦合在一起,不利于项目的维护.
  public interface UserService{
    public void delete(Integer id);
    public void update(User user);
  }
  public class UserServiceImpl implements UserService{
    public void delete(Integer id){
        //核心业务处理:删除  UserDAO.delete();
    }
    public void update(User user){
        //核心业务处理:更新  UserDAO.update();
    }
  }

//性能
  //事务
 
  静态代理类:组成:[target:核心业务]+[额外功能]
            :原则:代理(proxy)和目标(target)要有同样的方法实现(同样的接口实现)
      public class UserServiceProxy implements UserService{
        //原始的业务类
        private UserService us=new UserServiceImpl();
        public void delete(Integer id){
             //性能
             //事务
             us.delete(id);
             //事务
        }
        public void update(User user){
             //性能
             //事务
             us.update(id);
        }
      }
      new UserServiceProxy().update(user);
      new UserServiceProxy().delete(1);
  动态代理类搭建:
     1.准备原材料:target中的核心业务
                 :额外功能
     2.通过aop:编织,将原材料,动态的加载,称为一个代理类
     3.获取动态生成的代理类,完成相关业务.
======================================================================================
1.AOP :解决业务层中的问题
      :面向切面编程  代理模式   代理类
      :代理:target+Advice
      :切入点:切入了额外功能的 业务方法.
      :切面:切入点+额外功能
  OOP :面向对象编程  类 对象 接口  继承  封装  多态
=====================================================================================
2.动态代理搭建:*导入第三方的jar
  2.1 准备原材料
      *target
      *额外功能(Advice:建议)
             MethodBeforeAdvice       前置额外功能
         AfterReturningAdvice     后置额外功能
         MethodInterceptor        环绕额外功能
         ThrowsAdvice             异常时的额外功能(了解)
        implements MethodBeforeAdvice{
            /**
             * 主体逻辑:
             *   params:
             *      m:目标的方法对象
             *      params:目标方法的参数表,如果方法是空参,则params的长度为0.
             *      target:代理的目标
             */    
            public void before(Method m, Object[] params, Object target)
                    throws Throwable {
                //定制在目标的方法之前,执行的逻辑
                System.out.println("before: method:"+m.getName()+" params'length:"+params.length+" target:"+target);
            }
        }
  2.2 动态的编织代理类
      *声明原材料:target和advice
      *Weave:编织
        <!-- target -->
        <bean id="userService47" class="com.c47.serivce.UserServiceImpl"></bean>
        <!-- Advice -->
        <bean id="before47" class="com.c47.advice.MyBefore"></bean>
        <!-- 编织:基于aop schema完成编织 -->
        <aop:config>
            <!-- 1.目标,及其中需要附加额外功能的方法.
                 2.在目标中加入哪些额外功能
              -->
            <!--
                pointcut:切入点=目标中 附加了额外功能的方法
                execution()表达式:描述切入点
                       返回值   包  类  方法名  参数表
                * com.c47.service4.UserServiceImpl.*(..)
                * com.c47.service4.UserServiceImpl.deleteUser(..)
             -->
            <aop:pointcut id="pc47" expression="execution(* com.c47.service4.UserServiceImpl.*(..))"/>
            <!-- 在位置[pc47]上,附加额外功能[before47]  -->
            <aop:advisor advice-ref="before47" pointcut-ref="pc47"/>
        </aop:config>
  2.3 从工厂中获取动态代理对象:通过目标类的beanID即可,用接口类型引用接收.
===================================================================================  
3.额外功能:
  3.1 后置额外功能:AfterReturningAdvice
        implements AfterReturningAdvice{
            /**
             * 主体逻辑:
             *   params:
             *       ret:目标方法的返回值,如果方法是void,则ret为null
             *       m:目标方法对象
             *       paras:方法参数表
             *       target:目标对象
             */
            public void afterReturning(Object ret, Method m, Object[] params,
                    Object target) throws Throwable {
                System.out.println("after ret:"+ret+" method:"+m.getName()+" params'length:"+params.length+" target:"+target);
            }
        }
  3.2 环绕额外功能:
        implements MethodInterceptor{
            /**
             * 主体逻辑
             *   param:
             *      mi:
             */
            public Object invoke(MethodInvocation mi) throws Throwable {
                System.out.println("tx begin~~~");
                //调用目标的方法.
                Object ret=mi.proceed();
                System.out.println("tx commit~~~");
                //接收目标方法的返回值,并向上返回给用户.
                //注意:在环绕额外功能中,目标方法的返回值,务必要向上返回.
                return ret;
            }
        }
  3.3 异常时的额外功能:目标抛出异常时触发.(了解)
        implements ThrowsAdvice{
            /**
             * 主体逻辑:目标抛出异常时,执行
             * @param ex :抛出的异常对象
             */
            public void afterThrowing(Exception ex){
                System.out.println("my throws :"+ex.getMessage());
            }
        }
====================================================================================
4.execution表达式:描述切入点
  组成:返回值   包    类    方法名   参数表
  1>* com.c47.serivce.UserServiceImpl.deleteUser(..)
    返回值:任意
    包:com.c47.service
    类:UserServiceImpl
    方法:deleteUser
    参数表:任意
  2>* com.c47.serivce.UserServiceImpl.*(..)
    返回值:任意
    包:com.c47.service
    类:UserServiceImpl
    方法:任意
    参数表:任意
  3>* com.c47.serivce.*.*(..)
    返回值:任意
    包:com.c47.service
    类:任意
    方法:任意
    参数表:任意
  4>* *(..)
    返回值:任意
    包:任意
    类:任意
    方法:任意
    参数表:任意
  5>* login(..)
    返回值:任意
    包:任意
    类:任意
    方法:login
    参数表:任意
  6>技巧:* com.c47.serivce.UserServiceImpl.*User(..)
        返回值:任意
        包:com.c47.service
        类:UserServiceImpl
        方法:以User结尾的方法(便于批量的切入)
        参数表:任意
    建议:表达式,定义尽量精确.避免不必要的切入.
===================================================================================
*基于AOP,抽取事务管理:
  1>DAO,Service,SessionFactory,DataSource 纳入工厂
  2>IOC满足依赖
  3>Service不再依赖SessionFactory
  4>定制环绕额外功能:事务管理
  5>IOC满足事务管理器的依赖
  6>AOP将事务管理器切入需要事务的业务方法中.

1.原理:*动态代理类如何创建的.
          1>jdk代理  :通过和目标实现同一套接口,保证功能统一
          2>cglib代理:通过继承目标,保证功能统一.
          spring会动态的选择,如果目标有接口实现,则使用jdk代理,
          反之,则使用cglib.
       *为什么通过目标的BeanID===>Proxy
          1>BeanPostProcessor作用,再次加工.
======================================================================================
2.动态代理类如何创建(jdk代理):
        //1.目标 target
        final UserService us=new UserServiceImpl();
        //2.额外功能
        InvocationHandler ih=new InvocationHandler(){
            /**
             * method:方法对象
             * args:参数列表
             */
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                System.out.println("before~~~");
                //调用目标(us)的方法
                Object ret=method.invoke(us, args);
                System.out.println("after~~~");
                return ret;
            }
        };
        //3.编织  *类加载器   *目标的所有实现的接口   *额外功能
        UserService usProxy=(UserService)Proxy.newProxyInstance(TestAOPYL.class.getClassLoader()
                                                               ,us.getClass().getInterfaces()
                                                               ,ih);
====================================================================================
3.为什么通过目标的BeanID===>Proxy
  *BeanPostProcessor:后处理bean-->对工厂创建好的bean,进行再次的加工.
      被代理的Bean 生产过程:
      构造-->set-->
                postProcessBeforeInitialization-->
                init-->
                postProcessAfterInitialization-->
                用户
                
  *定制后处理bean:
            implements BeanPostProcessor{
                /**
                 * 在init之后执行
                 * param:bean=postProcessBeforeInitialization加工后的对象
                 */
                public Object postProcessAfterInitialization(final Object bean, String arg1)
                        throws BeansException {
                    
                }
                /**
                 * 在init之前执行
                 * param:bean=工厂供创建的目标的bean的对象
                 */
                public Object postProcessBeforeInitialization(Object bean, String arg1)
                        throws BeansException {
                    //加工
                    return bean;
                }
            }
   *<!-- 声明后处理bean
         则在获取当前配置中的任何一个bean时,后处理bean,就会进行再加工
     -->
    <bean class="com.c47.postprocessor.MyPostProcessor"></bean>
===================================================================================
4.spring事务管理:
  4.1 将 HibernateTransactionManager 纳入工厂,并IOC满足依赖:SessionFactory
        <!-- 并不是一个完整的事务管理器,其中,管理了事务控制的核心的逻辑
                     需要对其进一步的包装
        -->
        <bean id="tx47" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
            <property name="sessionFactory" ref="sessionFactory47"></property>
        </bean>
  4.2 进一步包装,获取真正的事务管理器
        <!-- 基于schema tx 包装真正的事务管理器
             事务属性(attributes):
                *隔离级别:1>读未提交   事务之间可以读取到彼此未提交的数据,会导致[脏读],并发性极好.
                                [脏读]:一个事务中读取到了其他事务中未提交的数据
                       2>读提交    事务之间只可以读取到彼此已提交的数据,可防止[脏读].但不能防止[不可重复读],并发性较好
                                [不可重复读]:一个事务中,多次读取统一条数据,结果不一致
                       3>可重复读     一个事务内,多次读取统一条数据,结果一致.可防止[脏读,不可重复读],但不能防止[幻影读],并发性较差
                                [幻影读]:一个事务中,多次读取统一张表,数据行数不一致.
                       4>序列化读  多个事务是串行发生.可以防止一切不合法的读取,并发性极差.
                      oracle:1.读提交(默认)  2.序列化读
                *传播性: REQUIRED:如果当前没有事务环境,开启事务;如果已有事务环境,则融入事务.
                       SUPPORTS:如果当前没有事务环境,则在非事务环境下执行;如果已有事务环境,则融入事务.
                *读写性:read-only="true" 只读事务,事务中只能读.
                      read-only="false" 读写时序,事务中可读 可写.
                *回滚时刻:rollback-for="java.lang.Exception" 在出现所有异常时,要回滚.
                                           细节:如果出现了RuntimeException,则会自动回滚.
                                                     但是如果出现了Exception,默认不会回滚,依然提交事务.
            事务特性:ACID
                    原子性
                    一致性
                    持久性
                    隔离性
        
        -->
        <tx:advice transaction-manager="tx47" id="txManager">
            <tx:attributes>
                <tx:method name="queryUserByID" propagation="SUPPORTS"/>
                <!-- <tx:method name="*User"/> -->
                <!-- 其余方法 -->
                <tx:method name="*" isolation="READ_COMMITTED" propagation="REQUIRED" read-only="false" rollback-for="java.lang.Exception"/>
            </tx:attributes>
        </tx:advice>
        *事务管理器,定制完毕,AOP切入业务层中即可
===================================================================================
5.spring对于DAO操作支持:进一步简化DAO操作
  HibernateTemplate:模板类,作用在DAO,将session封装到底层,构建了封装后的方法,以完成并
                   :简化DAO操作.
                   :集成session几乎所有的方法:get(),save(),delete(),update()
                   :如何执行HQL:template.find("HQL",Object... param);
                   :execute();//通用方法.
                        //execute方法会回调HibernateCallback中的doInHibernate
                        //且doInHibernate方法的返回值,就是execute方法的返回值.
                        template.execute(new HibernateCallback<List<User>>(){
                                //param:session 即当前线程中使用的session
                                public List<User> doInHibernate(Session session)
                                        throws HibernateException, SQLException {
                                    String hql="from User u order by u.id";
                                    Query query=session.createQuery(hql);
                                    query.setMaxResults(5);
                                    query.setFirstResult((pageNum-1)*5);
                                    return query.list();
                                }
                            }
                        );
                   :其中将事务的自动提交置为true.   connection.setAutoCommit(true);
                     template.save(xx);
                     template.delete(xx);
                     利于测试DAO.
===================================================================================

*spring   struts2   hibernate
 spring   struts2   mybatis
 基于注解的ssh
 *OpenSessionInViewFilter

1.spring+struts整合
  1>搭建struts2
  2>将Action纳入工厂(注意:prototype)
  3>IOC满足Action依赖
  4>导入插件包:struts2-spring-plugin.jar
              :在struts.xml配置Action时,<action  class="Action_BeanID" ....
              :保证前端控制器从工厂中获取需要的Action实例
  5>启动工厂:定制监听器=org.springframework.web.context.ContextLoaderListener
                       =在项目启动时,启动工厂
            :定制context-param=contextConfigLocation
                              =指示spring配置文件位置
======================================================================================
2.spring+mybatis整合:
  1>构建连接池
  2>通过SqlSessionFactoryBean构建SqlSessionFactory
    *依赖点:
        *数据源
        *别名设置(可选)
        *映射文件位置
  3>通过MapperScannerConfigurer构建DAO接口的实现类
    *依赖点:
        *SqlSessionFactory
        *DAO接口所在位置
    *构建出的DAO接口实现类,会纳入工厂,且ID为对应接口名的首字母小写
  4>将构建好的DAO注入给Service
  5>搭建DataSourceTransactionManager(注入数据源)
    并通过<tx:advice 进一步包装出mybatis的事务管理器,切入service方法中
  6>整合struts2....
=====================================================================================
3.基于注解SSH整合:
  1>//将当前类纳入工厂,bean的ID默认为类名的首字母小写:userDAOImpl
    //也可以明确指定bean的ID
    @Component("userDAO") 作用在类上
  2> //指示当前bean是非单例/单例(默认)的.
     @Scope(value="prototype/singleton")  作用在类上
  3>//基于类型自动注入
    @Autowired   作用在属性
    //基于名称自动注入
    @Resource(name="userService")  作用在属性
  4>//作用在类上:缺省的为类中的所有方法指定事务属性.
    //作用在方法上:为方法单独的指定事务属性
    @Transactional(isolation=Isolation.READ_COMMITTED,propagation=Propagation.REQUIRED,readOnly=false,rollbackFor=Exception.class)
  *告知spring注解位置:
        <context:component-scan base-package="com.c47"></context:component-scan>
  *告知spring,事务注解切入的是什么事务:
        <bean id="tx47" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <tx:annotation-driven transaction-manager="tx47"/>
=====================================================================================
4.OpenSessionInViewFilter:
  :被此过滤器过滤的请求,Session有此过滤器管理:session在事务结束后依然是开启的,直到
   视图渲染完毕后,将session关闭,以解决延迟加载异常.
      <!-- 配置OpenSessionInViewFilter
                      注意:要在前端控制器之前定义
                      此过滤器依赖SessionFactory,且默认向工厂所要id为:"sessionFactory"的bean
                      如果工厂中的SessionFactory的beanID不是"sessionFactory",通过init-param指定
      -->
      <filter>
        <filter-name>osiv47</filter-name>
        <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
        <init-param>
            <param-name>sessionFactoryBeanName</param-name>
            <param-value>sessionFactory47</param-value>
        </init-param>
      </filter>
      <filter-mapping>
        <filter-name>osiv47</filter-name>
        <!-- 需要在页面中使用延迟属性的请求 -->
        <url-pattern>/ssh/user_queryOneUser</url-pattern>
        <url-pattern>/user/a</url-pattern>
        <url-pattern>/user/b</url-pattern>
        <url-pattern>/user/c</url-pattern>
        <url-pattern>/user/d</url-pattern>
        <url-pattern>/a</url-pattern>
        <url-pattern>/b</url-pattern>
      </filter-mapping>
====================================================================================