Spring 基础学习一

1.什么是Spring
    --开源的轻量级应用开发框架
    --简化企业级应用程序开发，下降入侵性
    --为系统提供了一个总体的解决方法。
    --提供的IOC和AOP功能，能够将组建的耦合度价值最低
        便于系统往后的维护和升级
2.Spring的主要功能
    --DAO : Spring JDBC ; Transaction management
    --ORM : Hibemate、JPA、TopLink、JDO、OJB、iBatis
    --AOP : Spring AOP、AspectJ integration
    --JEE : JMX、JMS、JCA、Remoting、EJBs、Email
    --Web : Spring Web MVC、Framework Integration、Struts、
        WebWork、Tapestry、JSF...
    --Core: The IOC container

>>>>>>>>>>>>>>>>>>> Spring 容器 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
--在Spring中，任何的Java类和JavaBean都被当成Bean来处理
    这些Bean经过Spring容器 管理和使用。
--Spring容器实现了IOC机制和AOP机制，这些机制能够简化Bean对象
    的建立和管理Bean对象之间的关系(解耦)
--Spring容器三种类型：BeanFactory(接口)和ApplicationContext(接口)
    以及AbstractApplicationContext(具备关闭容器的方法)
1.Spring  容器的实例化
    --ApplicationContext继承自BeanFactory接口,且拥有更多的企业级方法。
    --须要有一个配置文件，applicationContext.xml
    <?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:context="http://www.springframework.org/schema/context" 
        xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
        xmlns:jee="http://www.springframework.org/schema/jee" 
        xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:aop="http://www.springframework.org/schema/aop" 
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:util="http://www.springframework.org/schema/util"
        xmlns:jpa="http://www.springframework.org/schema/data/jpa"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
            http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
            http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">        
    </beans>
    --实例化容器：
        String conf = "ApplicationContext.xml"
        ApplicationContext ac = 
            new ClassPathXmlApplicationContext(conf);
    注：ClassPathXmlApplicationContext类实例化了ApplicationContext
2.实例化一个Bean
    1）在容器配置文件中添加Bean定义
        <bean id="惟一标识符" class="包名.类名"/>
    2)实例化Spring容器
    3）调用getBean()方法获取Bean的实例
    ---Properties p = ac.getBean("config",Properties.class);
>>>>>>>>>>>>>>>>>>>> 容器对Bean的管理 <<<<<<<<<<<<<<<<<<<<<<<<<
1.Bean 的实例化
    1）构造器来实例化**重要**
    --id或name属性用于指定Bean的名称，用于从spring中查找这个Bean对象。
    --class：用于指定Bean类型，会自动调用无参构造器建立对象
    --使用无参构造器
       stp1:类应该提供无参构造器(或缺省构造器)
       stp2:在配置文件中。使用bean元素来配置
       stp3:调用容器的getbean方法
        <!-- 使用无参构造器建立对象 -->
        <!-- id属性：bean的名称，要求惟一
            class属性：bean的完整的类名 -->
        <bean id="eb" class="basic.ExampleBean"/>
    2）使用静态工厂方法实例化(了解)
        --factory-method 属性用于指定工厂中建立Bean对象的方法，
            必须用static修饰方法。
        <!-- 使用静态工厂方法建立对象 -->
        <!-- factory-method属性：指定一个静态方法 -->
        <bean id="cal" class="java.util.Calendar" 
            factory-method="getInstance"/>
    3）使用实例化工厂方法实例化(了解)
        <!-- 使用实例工厂方法建立对象 -->
        <!-- 
            factory-bean属性:某个bean的id，指定工厂Bean对象
            factory-method属性:指定实例方法，指定工厂中建立Bean对象的方法。
         -->
        <bean id="cal" class="java.util.Calendar" 
            factory-method="getInstance"/> 
        <bean id="date" factory-bean="cal" factory-method="getTime"/>
2.Bean的命名
    --每一个Bean都须要有名字(即标识符)，能够用id或name属性指定
    --若是须要指定一个别名的话，以下
        <alias name="date" alias="date1"/>
3.Bean的做用域
    --默认状况下，对于一个bean的配置，容器只会建立一个实例。
    <!-- 配置做用域 -->
    <!--  scope 属性的默认值是"singleton"(单例)
          若是属性值是"prototype",则每次调用getBean方法时，会建立一个新的实例-->
    <bean id="student" class="basic.Student" scope="prototype"/>    
    ▉做用域    ▉描述
    singleton    默认值，一个容器只建立一个对象实例
    prototype     调用一个getBean方法就建立一个新的实例
    request     在一次http请求中，一个Bean对应一个实例(web环境)
    session        在一个http session中，一个Bean对应一个实例(web环境)
  global Session 在全局的http session中，一个Bean对应一个实例
4.延迟加载
    --默认状况下，容器启动后，会将全部做用域为"singleton"的bean建立好。
    若是设置lazy-init属性值为true,表示延迟加载。
    (即容器启动以后，对于做用域为singleton的bean, 再也不建立相应的实例)
    <!-- 配置延迟加载
      lazy-init属性若是为true，表示延迟加载
      (即容器启动以后,对于此做用域为singleton的bean,再也不建立响应的实例)
     -->
    <bean id="tea1" class="basic.Teacher" lazy-init="true"/>
5.生命周期
    <!-- 初始方法
        init-method属性：初始化方法名
        destroy-method属性：销毁方法名
     -->
    <bean id="message" class = "basic.MessageBean" 
        init-method="init" destroy-method="destroy"/>
    --初始化:使用init-method属性来指定初始化方法。
    --销毁:使用destroy-method属性指定销毁方法。
    注:若是scope属性设置为prototype,则销毁方法不起做用。
    --须要使用具备关闭方法的子接口AbstractApplicationContext
    AbstractApplicationContext ac = 
        new ClassPathXmlApplicationContext("conf/basic2.xml");

>>>>>>>>>>>>>>>>>>>>>>>>>>> IOC <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

1.IOC是什么?
    --IOC:Inversion Of Controll 控制反转
    --指程序中对象的获取方式发生反转，由new建立方式转变为
        第三方框架建立、注入(DI),它下降了对象之间的耦合度
    --Spring容器才有DI方式实现了IOC控制，IOC是Spring的基础和核心
2.DI是什么？
    --DI: Dependcy injection 依赖注入
    --容器经过调用对象提供的set方法或者构造器来创建对象之间的依赖关系。
    注：IOC是目标,DI是手段。
3.使用set方法注入来创建对象之间的依赖关系
    --主要用于无参构造器注入属性的值
    <!-- 使用set 方法来注入对象之间的依赖关系 -->
    <bean id="a1" class="ioc.A" >
        <property name="b" ref="b1"></property>
    </bean>
    <bean id="b1" class="ioc.B"/>
    注：B类实例化A类中调用的一个接口，同理C类也能实例化这个接口
        也就是A类在不改代码的状况向下也能够调用C。
4.使用构造器注入来创建对象之间的依赖关系
    --经过调用带参的构造器来实现的
    --容器在实例化bean时，根据参数类型执行相应的构造器
    <bean id="b1" class="ioc.B"></bean>
    <!-- 配置构造器方式注入
        index属性：指定参数的下标（从0开始）
        ref属性：指定一个bean的id
     -->
    <bean id="a1" class="ioc.A">
        <constructor-arg index="0" ref="b1"/>
        <constructor-arg index="1" ref="c1"/>
        <constructor-arg index="2" value="参数3"/>
    </bean>
5.自动装配
    --spring容器依据某种规则，自动创建对象之间的依赖关系。
--规则：
    --默认状况下，容器禁止自动装配
  >>设置autowire属性让容器自动装配
    --byName:容器会查找id等于属性名称的bean，而后调用对应的set方法来完成注入
        若是找不到对应的bean，会注入null值
        --<bean id="rest" class="autowire.Restaurant" autowire="byName"/>    
    --byType:容器会查找与属性类型一致的bean，而后调用对应的set方法来完成注入。
        注意：若是找不到对应的bean，会注入null。找到多个值会报错。
        --<bean id="rest" class="autowire.Restaurant" autowire="byType"/>
    --constructor:相似byType，只不过调用的是构造器来完成注入
6.注入基本类型的值
    --使用value属性
    --使用value属性来完成注入
    <bean id="emp" class="other.ExampleBean" >
        <property name="name" value="小岳岳"/>
        <property name="age" value="18"/>
    </bean>
7.注入集合类型的值
----List
    <bean id="emp" class="other.ExampleBean" >
        <property name="cities">
            <list>
                <value>北京</value>
                <value>上海</value>
                <value>深圳</value>
                <value>深圳</value>
            </list>
        </property>
    </bean>
----Set
    <bean id="emp" class="other.ExampleBean" >
        <property name="interest">
            <set>
                <value>汽车</value>
                <value>打游戏</value>
                <value>看小说</value>
                <value>美食</value>
                <value>美食</value>
            </set>
        </property>
    </bean>
----map
    <bean id="emp" class="other.ExampleBean" >
        <property name="score">
            <map>
                <entry key="english" value="66"/>
                <entry key="math" value="99"/>
                <entry key="JAVA" value="80"/>
            </map>
        </property>
    </bean>
----properties
    <bean id="emp" class="other.ExampleBean" >
        <property name="db">
            <props>
                <prop key="username">tiger</prop>
                <prop key="passoword">1234</prop>
            </props>
        </property>
    </bean>
8.使用引用的方式注入集合类型的值
    --使用引用的方式注入集合类型的值
    --将集合配置成一个bean
        命名空间：类名
    <util:list id="citiesBean">
        <value>长沙</value>
        <value>岳阳</value>
        <value>华容</value>
    </util:list>
    <bean id="eb2" class="other.ExampleBean">
        <property name="cities" ref="citiesBean"/>
    </bean>
    --使用spring容器读取properties文件的内容
    <!-- 使用spring容器读取properties文件的内容,并存放到Properties对象。
        classpath:从类路径下面查找 -->
    <util:properties id="config" location="classpath:config.properties"/>
9.Spring表达式
    --用来访问bean或集合的值
    --Spring引入的一种表达式语言，与EL类似。
    <!-- 使用Spring表达式访问其余bean的属性 -->
    <bean id="sel" class="other.SpringELBean">
        <property name="name" value="#{emp.name}"/>
        <property name="city" value="#{citiesBean[1]}"/>
        <property name="score" value="#{emp.score['英语']}"/>
        <property name="pagesize" value="#{config.pagesize}"/>
    </bean>

>>>>>>>>>>>>>>>>>>>>> 组件扫描 <<<<<<<<<<<<<<<<<<<<<<<
--组件扫描：使用Spring主机代替XML配置来声明Bean，
    并使用注解来管理Bean对象
1.什么是组件扫描？
    --容器会扫描指定包及其子包下面的全部类，
    --若是该类包含有特定的注解(好比@Component),
    --则容器会将该类归入容器进行管理(至关于配置文件中有一个bean的配置）
2.如何使用组件扫描？
step1: 在类名前添加相应的注解
    @Component 通用组件
    @Service 业务层组件
    @Respository 持久层组件
    @Controller 控制层组件
step2: 在配置文件中配置文件扫描
    <!-- 配置组件扫描  base-package属性：包名 -->
    <context:component-scan base-package="annotation"/>
--@Component("id") : 缺省值是首字母小写的类名
3.做用域
    --类前面加 @Scope("prototype")
4.延迟加载
    --类前面加 @Lazy(true)    
5.生命周期：初始化和销毁回调
    --@PostConstruct和@PreDestroy
    --这两个注解来自于javaee,须要导入annotation.jar文件
    public class ExampleBean {
        @PostConstruct
        public void init(){    }
        @PreDestroy
        public void destroy(){}
    }
6.注入Spring表达式的值
    -- @Value("#{sping表达式}")
    注：该注解能够加到属性前,也能够加到属性的set方法前面
        加载属性前面，使用的是反射的直接赋值
    1）在xml配置中指定要注入的properties文件
        <util:properties id="config" 
            location="classpath:config.properties"/>
    2）在属性前面使用@value注解
        @Component("mb")
        public class MessageBean {
            @Value("#{config.pagesize}")
            private String pagesize;
            @Value("北京市海淀区")
            private String address;
        }
7.指定依赖注入关系
    --具备依赖关系的Bean对象，
        利用如下任意一种注解均可以实现关系注入
    --@Autowired/@Qualifier
        能够处理构造器注入和Set方法注入(包括加在属性前面)
        --@Autowired加到set方法前面，
        --@Qualifier用来指定 要注入的bean的id。
    注，若是不使用@Qualifier,会使用 byType的方式来注入
    --@Resource
        只能处理Set注入(包括加在属性前面)
    --@Inject/@Named (了解)
        和Autowire用法一致
    1）@Autowired/@Qualifier
    @Component("rest")
    public class Restaurant {
        @Autowired
        @Qualifier("wt")
        private Waiter wt;
        @Autowired
        public School(@Qualifier("wt") Waiter wt) {
            this.wt = wt;
        }
    }
    2）@Resource (也能够放在set方法前面)
    @Component("bar")
    public class Bar {
        @Resource(name="wt") 
        private Waiter wt;
    }
8.注入Spring表达式值
    --@Value 注解能够注入spring表达式值
    1）在XML配置中指定要注入的properties文件
        <util:properties id="const" location="classpath:comst.properties"/>
    2)而后在属性或Setter方法前使用@Value注解
        @Component
        public class DemoBean{
            @Value("#{const.PAGE_SIZE}")
            private int pageSize;
        }

>>>>>>>>>>>>>>>>>>>>>> Spring-MVC **重要** <<<<<<<<<<<<<<<<<<<<<<<<<<<
1.SpringMVC是什么？
    --是Spring框架的一个功能模块
    --一个用来简化开发MVC结构的web的框架。
    注：SpringMVC属于Spring框架的一部分

2.SpringMVC的五大组件：
    -- DispatcherServlet (前端控制器，请求入口) 
    -- HandlerMapping (请求派发)
        入口：SimpleUrlHandlerMapping
    -- Controller (处理器，请求处理流程)
    -- ModelAndView (模型，防撞业务处理结果和视图)
    -- ViewResolver (视图解析器,视图显示处理器)
        出口：InternalResourceViewResolver
step1,DispatcherServlet收到请求以后，
    依据 HandlerMapping的配置，调用相应的Controller.handleRequest来处理。
step2,Controller将处理结果封装到ModelAndView对象。 
    而后将该对象返回给DispatcherServlet来处理。 
    ◆注：ModelAndView对象包含有两部分数据，一是处理结果，     
    另外，还包含有视图名(就是一个字符串，好比"hello")。 
step3,DispatcherServlet依据ViewResolver的解析，
    调用相应的视图对象(好比jsp)来生成相应的页面。
3.编程步骤
    step1,导包 spring-webmvc 
    step2,添加spring的配置文件。
    step3,配置DispatcherServlet。(web.xml)
    step4,写Controller类。
    step5,写jsp。
    step6,配置HandlerMapping和ViewResolver。

    <!-- 配置HandlerMapping -->
    <!-- 
        HandlerMapping告诉DispatcherServlet请求地址(url)与处理器(Controller)的对应关系
     -->
     <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
         <property name="mappings">
             <props>
                 <prop key="/hello.do">hc</prop>
             </props>
         </property>
     </bean>
     <bean id="hc" class="controller.HelloController"/>

     <!-- 配置ViewResolver -->
     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="prefix" value="/WEB-INF/"/>
         <property name="suffix" value=".jsp"/>
     </bean>

>>>>>>>>>>>>>>>>>>> 基于注解的SpringMVC应用<<<<<<<<<<<<<<<<<<<<<<<<
1.编程步骤
    step1. 导包。
    step2. 添加spring配置文件。
    step3. 配置DispatcherServlet。
    step4. 写Controller。
    a. 不用实现Controller接口。
    b. 能够添加多个方法。
    c. 方法名称不做要求，返回值的类型能够是 ModelAndView，也能够是String。
    d. 在类名前添加@Controller。
    e. 在类名前或者方法前添加@RequestMapping。
    ◆注：@RequestMapping的做用至关于HandlerMapping。
    step5. 写jsp。
    step6. 配置视图解析器，配置组件扫描, 配置springmvc注解扫描
        (让spring容器可以识别 @RequestMapping)。

2.使用@Controller注解声明Controller组件    
    --这样能够不实现Controller接口，
        请求方式也能够灵活定义
    @Controller
    public class BmiController {
    }
    --为了@Controller注解生效，须要配置Spring的XML文件
    <!-- 配置包扫描 -->
    <context:component-scan base-package="controller"/>
    --为了开启@RequestMapping注解映射,须要配置Spring的XML文件
    <!-- 配置注解扫描 Spring 3.2版本之后 -->
    <mvc:annotation-driven/>

3.接收请求参数
    /**
     * 第一种方式，使用request获取请求参数
     */
    @RequestMapping("/login.do")
    public String checkLogin(HttpServletRequest req){
        String adminCode = req.getParameter("adminCode");
        String pwd = req.getParameter("pwd");
        return "index";
    }
    /**
     * 第二种方式，使用@RequestParam获取请求参数
     *         即便形参名字和传过来的key值一致，
     *         最好在每一个形参前面加上@RequestParam
     *         由于Java反射机制不记录形参的名字
     */
    @RequestMapping("/login2.do")
    public String checkLogin2(
            @RequestParam("adminCode")String adminCode, 
            @RequestParam("pwd")String password){
        System.out.println(adminCode+";"+password);    
        return "index";
    }
    /**
     * 推荐使用
     * 第三种方式，封装成一个JavaBean获取请求参数
     *     1.写一个Java类，属性和传入的参数对应
     *     2.处理方法须要带有这个Java类的参数
     */
    @RequestMapping("/login3.do")
    public String checkLogin3(Admin a){
        System.out.println(a.getAdminCode()+";"+a.getPwd());    
        return "index";
    }
    /**
     *用于封装请求参数值的JavaBean，要求：
     *    1.属性名与请求参数名一致
     *     2.属性值有对应的get/set方法
     */
    public class Admin implements Serializable {
        private String adminCode;
        private String pwd;
        public String getAdminCode() {
            return adminCode;
        }
        public void setAdminCode(String adminCode) {
            this.adminCode = adminCode;
        }
        public String getPwd() {
            return pwd;
        }
        public void setPwd(String pwd) {
            this.pwd = pwd;
        }
    }

4.向页面传值
方式一；将数据绑定到request对象
    /**向页面传值
     * 第一种方式：绑定数据到request对象
     */
    @RequestMapping("/login4.do")
    public String checkLogin4(Admin a,HttpServletRequest req){
        req.setAttribute("adminCode", a.getAdminCode());
        //SpringMVC 默认使用转发机制来跳转
        return "index";
    }
方式二；返回对象ModelAndView对象
    /**
     * 第二种方式：返回ModelAndView对象
     */
    @RequestMapping("/login5.do")
    public ModelAndView checkLogin5(Admin a){
        System.out.println("checkLogin5()");
        System.out.println(a);
        Map<String,Object> model = new HashMap<String,Object>();
        model.put("adminCode", a.getAdminCode());
        return new ModelAndView("index", model);
    }
方式三：将ModelMap做为方法入参
    /**
     * 第三种方式：将ModelMap做为方法入参
     */
    @RequestMapping("/login6.do")
    public String checkLogin6(Admin a,ModelMap mm){
        System.out.println("checkLogin6()");
        System.out.println(a);
        mm.addAttribute("adminCode", a.getAdminCode());
        return "index";
    }

方式四：将数据绑定到session对象
    /**
     * 第四种方式：将数据绑定到session对象
     */
    @RequestMapping("/login7.do")
    public String checkLogin7(Admin a,HttpSession session){
        System.out.println("checkLogin7()");
        System.out.println(a);
        session.setAttribute("adminCode", a.getAdminCode());
        return "index";
    }
5.重定向
    
    /**
     * 方式一：返回值是String
     */
    @RequestMapping("/login8.do")
    public String checkLogin8(){
        System.out.println("checkLogin8()");
        return "redirect:toIndex.do";
    }
    @RequestMapping("/toIndex.do")
    public String toIndex(){
        return "index";
    }
    /**
     * 方式二：返回值是ModelAndView
     */
    @RequestMapping("/login9.do")
    public ModelAndView checkLogin9(){
        RedirectView rv = new RedirectView("toIndex.do");
        return new ModelAndView(rv);
    }
    @RequestMapping("/toIndex.do")
    public String toIndex(){
        return "index";
    }

6.解决接收数据乱码问题
    在web.xml文件当中,配置springmvc提供的一个过滤器(CharacterEncodingFilter)。
    须要注意：
        a.表单提交方式必须设置为"post"。
        b.过滤器的编码设置与表单的编码要一致。
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
7.拦截器
    1）什么是拦截器?
        --前端控制器在调用处理器以前，若是发现有拦截器存在， 
            则会先调用拦截器，而后再调用处理器。
        ◆注：过滤器属于servlet规范当中定义的组件，
            而拦截器 属于spring框架定义的组件。
    2）如何写一个拦截器?
        step1. 写一个java类，实现HandlerInterceptor接口。
        public class SomeInterceptor implements HandlerInterceptor {
            //handler:处理器方法对象
            public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler)
                    throws Exception {
                //方法体
                return true;
            }
            public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                    ModelAndView modelAndView) throws Exception {
                //方法体
            }
            // ex:处理器抛出异常
            public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                    throws Exception {
                //方法体
            }
        }
        step2. 将拦截处理逻辑写在相应的接口方法里面:
        --preHandle方法：前端控制器先调用拦截器的preHandle方法， 
            若是该方法返回值为true,则拦截器继续向后调用；
            若是 该方法返回值为false,则拦截器再也不向后调用,请求处理完成。
        --postHandle方法：处理器方法已经执行完成，
            正准备将 ModelAndView对象返回给前端控制器以前执行。
            能够在 该方法里面，修改ModelAndView对象。
        --afterCompletion方法：最后执行的方法，要注意，
            若是 preHandle方法返回值为false,该方法不会执行。
        step3. 配置拦截器。
        <!-- 拦截器 -->
        <!-- 能够配置多个拦截器，配置的前后顺序决定了拦截器执行的前后顺序 -->
        <mvc:interceptors>
            <mvc:interceptor>
                <-- /** 表示全部 -->
                <mvc:mapping path="/**"/>
                <mvc:exclude-mapping path="/toLogin.do"/>
                <mvc:exclude-mapping path="/login.do"/>
                <mvc:exclude-mapping path="/createImg.do"/>
                <bean class="com.tarena.netctoss.
                        interceptors.SessionInterceptor"/>
            </mvc:interceptor>
        </mvc:interceptors>
8.让spring框架来处理异常
    --将异常抛给spring，由spring框架依据相应的配置，来处理异常。
    方式一： 使用简单异常处理器。
        --适合全局处理简单异常
        step1. 配置简单异常处理器。
        <!-- 简单异常处理器 -->
        <bean class="org.springframework.web.servlet.
            handler.SimpleMappingExceptionResolver">
            <property name="exceptionMappings">
                <props>
                    <-- key是异常的类型，value是跳转的视图页面 -->
                    <prop key="java.lang.Exception">hello1_error</prop>
                </props>
            </property>
        </bean>     
        step2. 编写异常处理页面。即：hello1_error.jsp
    方式二: 使用@ExceptionHandler或者实现HandlerExceptionResolver接口
    --适合全局处理有“处理过程”的异常
    step1. 在处理器类当中，添加一个用来处理异常的方法， 
        该方法必须添加@ExceptionHandler。
    step2. 在异常处理方法里面，依据异常类型，分别进行不一样的处理。
    /**
     * ex： 其余方法抛出的异常
     * 这是一个异常处理方法，能够处理其余方法抛出的异常
     */
    @ExceptionHandler
    public String excute(Exception ex, HttpServletRequest req){
        if(ex instanceof NumberFormatException){
            req.setAttribute("error", "请输入数字");
            return "error";
        }
        if(ex instanceof StringIndexOutOfBoundsException){
            req.setAttribute("error", "数组越界");
            return "error";
        }
        //其余异常
        req.setAttribute("error", "系统异常，请稍后再试");
        return "error";
    }

>>>>>>>>>>>>>>>>>>>>>>>>> spring jdbc <<<<<<<<<<<<<<<<<<<<<<<< 1.spring jdbc是什么?     --spring框架对jdbc的封装。 2.如何使用spring jdbc?     --spring框架提供了一个JdbcTemplate类，提供了大量的 实现的方法，     咱们只须要配置好该对象，而后调用其方法便可。 --step1.导包 : spring-webmvc,ojdbc,dbcp,junit,spring-jdbc --step2.添加spring配置文件,配置JdbcTemplate。     <!-- 配置DataSource -->     <bean id="ds" class="org.apache.commons.dbcp.BasicDataSource"         destroy-method="close">         <property name="driverClassName" value="#{db.driver}" />         <property name="url" value="#{db.url}" />         <property name="username" value="#{db.user}" />         <property name="password" value="#{db.pwd}" />         <property name="initialSize" value="#{db.initSize}" />         <property name="maxActive" value="#{db.maxSize}" />     </bean>     <!-- 配置JdbcTemplates -->     <bean id="jt" class="org.springframework.jdbc.core.JdbcTemplate">         <property name="dataSource" ref="ds" />     </bean> --step3.调用JdbcTemplate的方法来访问数据库。     @Repository     public class EmpDao {         @Resource(name="jt")         private JdbcTemplate jt;             /**          * JdbcTemple 会将底层的异常捕获以后，统一转化成运行异常统一抛出          */         public void save(Emp emp){             String sql = "INSERT INTO emp_zxc VALUES(seq_emp_zxc.nextval,?,?)";             Object[] param = new Object[]{emp.getName(),emp.getAge()};             jt.update(sql,param);         }     }