框架

笔记 专栏收录该内容
77 篇文章 1 订阅

一.spring

    1.Ioc/Di

       IOC/DI的内容参考博客:

       https://www.cnblogs.com/Mr-Rocker/p/7721824.html

     (1)理解IOC/DI

            (a)Ioc—Inversion of Control,即“控制反转”,不是什么技术,而

                     是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象

                   (这里的对象不只是java对象,指一切外部资源,如图片、文本

                     等)交给容器控制,而不是传统的在你的对象内部直接控制。

                     理解IOC要弄清楚两个概念:

                     概念一:有反转就有正转,那么什么是正转?什么是反转

                                    正转,就是传统应用程序是由我们自己在对象中主动控

                                               制去直接获取依赖对象。

                                    反转:就是由容器来帮忙创建及注入依赖对象。

                     概念二:谁控制谁,又控制什么?

                                    传统的应用中程序是通过new主动创建依赖对象,而

                                    IoC是有专门一个容器来创建这些对象。所以是由IOC

                                    容器控制所依赖的对象。

                                    

            (b)DI—Dependency Injection,即“依赖注入”组件之间依赖关

                     系由容器在运行期决定,形象的说,即由容器动态的将某个依

                     赖关系注入到组件之中。依赖注入的目的并非为软件系统带来

                     更多功能,而是为了提升组件重用的频率,并为系统搭建一个

                     灵活、可扩展的平台。

                     首先弄清楚一个问题,DI是怎么来的?

                            由于控制反转概念比较含糊(可能只是理解为容器控制对

                     象这一个层面,很难让人想到谁来维护对象关系),所以2004

                     年大师级人物Martin Fowler又给出了一个新的名字:“依赖注入”,

                     相对IoC 而言,“依赖注入”明确描述了“被注入对象依赖IoC容器

                     配置依赖对象”。

                     其次弄清楚:谁依赖谁,为什么需要依赖,谁注入谁,注入了

                                          什么

                            * 谁依赖于谁:当然是应用程序依赖于IoC容器;

                       * 为什么需要依赖:应用程序需要IoC容器来提供对象需要

                                                           的外部资源;

                       * 谁注入谁:很明显是IoC容器注入应用程序某个对象,应

                                                 用程序依赖的对象;

                       * 注入了什么:就是注入某个对象所需要的外部资源(包括

                                                    对象、资源、常量数据)。

     (2)依赖注入和控制反转是同一概念吗?

              不是同一概念, 但是它们两个描述的是同一件事件,但是是从不同

              的角度来说,控制反转是从IoC/DI容器的角度;依赖注入是从应用

              程序的角度。

              控制反转的描述:IoC/DI容器反过来控制应用程序,控制应用程序

                                           锁所需要的外部资源(比如:外部资源)

              依赖注入的描述:应用程序依赖IoC/DI容器,依赖它注入所需要的

                                           外部资源。

     (3)IOC/DI给我们带来的好处

              IoC 不是一种技术,只是一种思想,一个重要的面向对象编程的法

              则,它能指导我们如何设计出松耦合、更优良的程序。传统应用程

              序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高

              耦合,难于测试;有了IoC容器后,把创建和查找依赖对象的控制

              权交给了容器,由容器进行注入组合对象,所以对象与对象之间是

              松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序

              的整个体系结构变得非常灵活。

     (4)Ioc/Di原理

              没有找到答案,网上都在放屁,如果面试问道就回答由容器管理bean

              实现依赖注入、反射之类云云。

    2.Spring Aop

     (1)了解为什么会有Aop,Aop是为了解决什么问题而产生的,浏览下面的文章

           https://blog.csdn.net/javazejian/article/details/56267036

    (2)Aop原理

             Aop的原理是使用了代理模式。代理模式可以做到在不修改目标对象的功能前提

            下,对目标功能扩展。.Spring Aop使用的代理是jdk动态代理和Cglib代理。

            http://blog.csdn.net/javazejian/article/details/56267036(简单易懂的文档)。该

            文档可以在阅读下文前看也可以在阅读下文之后看。

          (a)静态代理,直接看例子

                   写代码时候的思路:

                   -  代理类和目标对象实现同一个接口

                   -  目标对象传入代理类

                   -  代理类里坐增强

/**
 * 接口
 */
public interface IUserDao {

    void save();
}

/**
 * 接口实现
 * 目标对象
 */
public class UserDao implements IUserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}


/**
 * 代理对象,静态代理
 */
public class UserDaoProxy implements IUserDao{
    //接收保存目标对象
    private IUserDao target;
    public UserDaoProxy(IUserDao target){
        this.target=target;
    }


    public void save() {
        System.out.println("开始事务...");
        target.save();//执行目标对象的方法
        System.out.println("提交事务...");
    }
}


/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        //目标对象
        UserDao target = new UserDao();
        //代理对象,把目标对象传给代理对象,建立代理关系
        UserDaoProxy proxy = new UserDaoProxy(target);
        proxy.save();//执行的是代理的方法
    }
}

                   静态代理缺点:因为代理对象需要与目标对象实现一样的接口,所以会有很多

                                            代理类,同时一旦接口增加方法,目标对象与代理对象都要维

                                            护,所以有了下面的动态代理。

          (b) 动态代理

                    动态代理也叫jdk代理,不用实现接口。

                    代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我

                    们指定创建代理对象/目标对象实现的接口的类型)。

                    所在包:java.lang.reflect.Proxy

                    使用方法:static Object newProxyInstance(ClassLoader loader,

                                      Class<?>[] interfaces,InvocationHandler h )   

                    ClassLoader loader:指定当前目标对象使用类加载器,获取加载器的方法是

                                                       固定的。

                    Class<?>[] interfaces:目标对象实现的接口的类型,使用泛型方式确认类型。

                    InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理

                                                        器的方法,会把当前执行目标对象的方法作为参数传

                                                        入。

                  下面看动态代理的例子:    

/**
*接口
*/
public interface Say {
    void sayHello(String words);
}


/**
*实现类
**/
public class SayImpl implements Say {
    @Override
    public void sayHello(String words) {
        System.out.println("hello:" + words);
    }
}


/**
 * 创建动态代理对象 动态代理不需要实现接口,但是需要指定接口类型
 */

public class TestInvocationHandler implements InvocationHandler {

    private Object target;
    public TestInvocationHandler(Object target) {
        this.target=target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("invoke begin");
        System.out.println("method :"+ method.getName()+" is invoked!");
        method.invoke(target,args);
        System.out.println("invoke end");
        return null;
    }
}


/**
*测试类
**/
public static void main(String[] args) {

        TestInvocationHandler testInvocationHandler = 
        new TestInvocationHandler(new SayImpl());
        Say say = (Say)Proxy.newProxyInstance(SayImpl.class.getClassLoader(), 
        SayImpl.class.getInterfaces(), testInvocationHandler );
        say.sayHello("my dear");
    }


执行结果:
invoke begin
method :sayHello is invoked!
hello:my dear
invoke end

                 

                  静态代理和动态代理区别之简单说法:

                         静态代理:编译时就确认了代理类

                         动态代理:运行时由反射确认代理类,并且能代理各种类型的对象

                  静态代理和动态代理的区别之详细说法:

                          静态代理源码由程序员创建,再编译代理类。所谓静态也就是在程序运

                          行前就已经存在 代理类的字节码文件,代理类和委托类的关系在运行前

                          就确定了;动态代理类的源码是在程序运行期间由JVM根据反射等机制

                          动态的生成,所以不存在代理类的字节码文件。代理类和委托类的关系

                          是在程序运行时确定。                 

          (c)Cglib代理

                   上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对

                   象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这

                   个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做Cglib

                   代理。例子如下:      

/**
* 目标对象,没有实现任何接口
*/
public class UserDao {
public void save() {
        System.out.println("----已经保存数据!----");
    }
}


/**
* Cglib子类代理工厂
* 对UserDao在内存中动态构建一个子类对象
*/
public class ProxyFactory implements MethodInterceptor{
    //维护目标对象
    private Object target;


    public ProxyFactory(Object target) {
        this.target = target;
    }


    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();


    }


    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");


        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);


        System.out.println("提交事务...");


        return returnValue;
    }
}

                    Cglib代理和JDK动态代理的区别:

                    JDK动态代理只能对实现了接口的类生成代理,而不能针对类;CGLIB是针

                    对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法(继承)

                    当Bean实现接口时,Spring就会用JDK的动态代理;当Bean没有实现接口

                    时,Spring使用CGlib是实现;可以强制使用CGlib(在spring配置中加入

                    <aop:aspectj-autoproxy proxy-target-class="true"/>)CGlib比JDK快 

                   使用CGLib实现动态代理,CGLib底层采用ASM字节码生成框架,使用字节

                   码技术生成代理类,比使用Java反射效率要高。唯一需要注意的是,CGLib

                   不能对声明为final的方法进行代理,因为CGLib原理是动态生成被代理类的

                   子类。在对JDK动态代理与CGlib动态代理的代码实验中看,1W次执行下,

                   JDK7及8的动态代理性能比CGlib要好20%左右。

     (3)Aop中术语

              配合:https://blog.csdn.net/yuanlaijike/article/details/79493801

                         https://www.jianshu.com/p/5015f212e4e4

                         http://www.cnblogs.com/hongwz/p/5764917.html(主要看其中对Aop术

                         语的解释,结合本篇博客整理的,可以容易理解术语)

           (a)关注点:又“名横切关注点”,是影响应用多处的功能(安全、事务、日志)

                    我的理解:是我们所关心的共性的功能,比如用户日志记录、用户的验证

          (b)切面:横切关注点被模块化为特殊的类,这些类称为切面。类是对物体特

                              征的抽象,切面就是对横切关注点的抽象。

                   我的理解:关注点的模块化,就像类一种抽象概念。比如我们把日志记录、

                                     用户验证等功能抽象出来进行设计。面向对像是对事务属性和

                                     行为进行抽象。而面向切面是对共性功能进行抽象,所以说是

                                     oop的一种补充。

                   这样做的好处

                           -  关注点在需要增加或删除这些共性功能的时候不需对目标模块进行

                              修改,实现了快速插拔

                           -  使得系统架构更优良,分而治之,关注点只需要关注自身要实现的

                              共性的功能,服务模块只需要关注自身的核心功能,这样设计胜过

                              共性功能糅杂进服务模块

          (c)连接点:程序执行的某个特定位置:如类开始初始化前、类初始化后、类

                                 某个方法调用前、调用后、方法抛出异常后。一个类或一段程序

                                 代码拥有一些具有边界性质的特定点,这些点中的特定点就称为

                                 “连接点”。Spring仅支持方法的连接点,即仅能在方法调用前、

                                 方法调用后、方法抛出异常时以及方法调用前后这些程序执行点

                                 织入增强。连接点由两个信息确定:第一是用方法表示的程序执

                                 行点;第二是用相对点表示的方位。

                                         连接点是一个应用执行过程中能够插入一个切面的点。连接

                                 点可以是调用方法时、抛出异常时、甚至修改字段时、切面代码

                                 可以利用这些点插入到应用的正规流程中程序执行过程中能够应

                                 用通知的所有点。

                  解释:所谓连接点,也就是目标对象或者代理对象之中的方法(方法调用

                             前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行

                             点)。为什么说2个都 可以呢?因为如果是jdk实现的动态代理的话,

                             那么目标对象和代理对象要实现共同的接口,如果是cglib实现的动

                             态代理的话,那么代理对象类是目标对象类的子类。都是一个方法

                             啦。所以这么理解就OK的啦。

          (d)切入点:对连接点进行拦截的定义。上面说的连接点的基础上,来定义切

                                 入点,你的一个类里,有15个方法,那就有几十个连接点了对把,

                                 但是你并不想在所有方法附近都使用通知(使用叫织入,以后再

                                 说),你只想让其中的几个,在调用这几个方法之前,之后或者

                                 抛出异常时干点什么,那么就用切点来定义这几个方法,让切点

                                 来筛选连接点,选中那几个你想要的方法。连接点相当于数据库

                                 中的记录,而切点相当于查询条件。切点和连接点不是一对一的

                                 关系,一个切点可以匹配多个连接点。

          (e)引入:引入允许我们向现有的类中添加方法或属性。

          (f)织入:织入是将切面应用到目标对象来创建的代理对象过程.

          (g)通知:所谓通知指的就是指拦截到连接点之后要执行的代码。执行的代码

                              就是切面要完成的工作,在 AOP 术语中,切面的工作被称为通知。

                   工作内容:通知定义了切面是什么以及何时使用。除了描述切面要完成

                                     的工作,通知还解决何时执行这个工作。

                   Spring 切面可应用的 5 种通知类型:

                               Before——在方法调用之前调用通知。

                               After——在方法完成之后调用通知,无论方法执行成功与否。

                               After-returning——在方法执行成功之后调用通知。

                               After-throwing——在方法抛出异常后进行通知。

                               Around——通知包裹了被通知的方法,在被通知的方法调用之

                                                  前和调用之后执行自定义的行为。

          (h)最后上一张图,配合上面(a)、(b)、(c)、(d)、(e)、(f)

                   一起理解。

                   参考文章:

                   http://blog.csdn.net/github_34889651/article/details/51321499

                   http://blog.csdn.net/qq_27093465/article/details/53351403

                 

    (4)Spring中如何使用Aop,下面是一些例子    

             XML的实现方式

                    例一,基于Spring的AOP简单实现

                            定义一个接口:

public interface HelloWorld
{
    void printHelloWorld();
    void doPrint();
}

                            定义两个实现类:

public class HelloWorldImpl1 implements HelloWorld
{
    public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl1.printHelloWorld()");
    }
    
    public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl1.doPrint()");
        return ;
    }
}

 

public class HelloWorldImpl2 implements HelloWorld
{
    public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl2.printHelloWorld()");
    }
    
    public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl2.doPrint()");
        return ;
    }
}

                            横切关注点,这里是打印时间:

public class TimeHandler
{
    public void printTime()
    {
        System.out.println("CurrentTime = " + System.currentTimeMillis());
    }
}

                            aop.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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
        
        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        
        <aop:config>
            <aop:aspect id="time" ref="timeHandler">
                <aop:pointcut id="addAllMethod" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="printTime" pointcut-ref="addAllMethod" />
                <aop:after method="printTime" pointcut-ref="addAllMethod" />
            </aop:aspect>
        </aop:config>
</beans>

                            写一个main函数调用一下: 

public static void main(String[] args)
{
    ApplicationContext ctx = 
            new ClassPathXmlApplicationContext("aop.xml");
        
    HelloWorld hw1 = (HelloWorld)ctx.getBean("helloWorldImpl1");
    HelloWorld hw2 = (HelloWorld)ctx.getBean("helloWorldImpl2");
    hw1.printHelloWorld();
    System.out.println();
    hw1.doPrint();
    
    System.out.println();
    hw2.printHelloWorld();
    System.out.println();
    hw2.doPrint();
}


运行结果:

CurrentTime = 1446129611993
Enter HelloWorldImpl1.printHelloWorld()
CurrentTime = 1446129611993

CurrentTime = 1446129611994
Enter HelloWorldImpl1.doPrint()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.printHelloWorld()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.doPrint()
CurrentTime = 1446129611994

                       例二,增加一个横切关注点,打印日志,Java类为

public class LogHandler
{
    public void LogBefore()
    {
        System.out.println("Log before method");
    }
    
    public void LogAfter()
    {
        System.out.println("Log after method");
    }
}
<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
        
        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        <bean id="logHandler" class="com.xrq.aop.LogHandler" />
        
        <aop:config>
            <aop:aspect id="time" ref="timeHandler" order="1">
                <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="printTime" pointcut-ref="addTime" />
                <aop:after method="printTime" pointcut-ref="addTime" />
            </aop:aspect>
            <aop:aspect id="log" ref="logHandler" order="2">
                <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="LogBefore" pointcut-ref="printLog" />
                <aop:after method="LogAfter" pointcut-ref="printLog" />
            </aop:aspect>
        </aop:config>
</beans>

                               测试类不变,打印结果为:

CurrentTime = 1446130273734
Log before method
Enter HelloWorldImpl1.printHelloWorld()
Log after method
CurrentTime = 1446130273735

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl1.doPrint()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl2.printHelloWorld()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273737
Log before method
Enter HelloWorldImpl2.doPrint()
Log after method
CurrentTime = 1446130273737

                               要想让logHandler在timeHandler前使用有两个办法:

                             (a)aspect里面有一个order属性,order属性的数字就是横切关注

                                      点的顺序。

                             (b)把logHandler定义在timeHandler前面,Spring默认以aspect

                                      的定义顺序作为织入顺序。

                     例三,我只想织入接口中的某些方法,修改一下pointcut的expression

                                就好了。

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
        
        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        <bean id="logHandler" class="com.xrq.aop.LogHandler" />
        
        <aop:config>
            <aop:aspect id="time" ref="timeHandler" order="1">
                <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.print*(..))" />
                <aop:before method="printTime" pointcut-ref="addTime" />
                <aop:after method="printTime" pointcut-ref="addTime" />
            </aop:aspect>
            <aop:aspect id="log" ref="logHandler" order="2">
                <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.do*(..))" />
                <aop:before method="LogBefore" pointcut-ref="printLog" />
                <aop:after method="LogAfter" pointcut-ref="printLog" />
            </aop:aspect>
        </aop:config>
</beans>

         强制使用CGLIB生成代理

                前面说过Spring使用动态代理或是CGLIB生成代理是有规则的,高版本的

                Spring会自动选择是使用动态代理还是CGLIB生成代理内容,当然我们也

                可以强制使用CGLIB生成代理,那就是<aop:config>里面有一个

                "proxy-target-class"属性,这个属性值如果被设置为true,那么基于类的

                代理将起作用,如果proxy-target-class被设置为false或者这个属性被省略,

                那么基于接口的代理将起作用。

    4.Spring事务

    (1)首先看下数据库的事务

           (a)A、C、I、D。

                   原子性(Atomic):事务中各项操作,要么全做要么全不做,任何一项操

                                               作的失败都会导致整个事务的失败。

                   一致性(Consistent):事务结束后系统状态是一致的。

                   隔离性(Isolated):并发执行的事务彼此无法看到对方的中间状态。

                   持久性(Durable):事务完成后所做的改动都会被持久化,即使发生灾

                                                难性的失败。通过日志和同步备份可以在故障发生

                                                后重建数据。

                   关于原子性和一致性的区别:

                   张三给李四转账100元,需要先重张三的账户上减去100元,在给李四

                   的账户上增加100元,如果张三减去100失败那么整个事物就回滚,这

                   就是原子性的体现;假设张三李四的账户在转账前都是1000元,那么

                   转账后张三账户为900元,李四账户为1100元,这就是一致性的体现。

           (b)事务的隔离级别

                    READ UNCOMMITTED 幻读、不可重复读和脏读都允许。

                    READ COMMITTED 允许幻读、不可重复读,不允许脏读。

                    REPEATABLE READ 允许幻读,不允许不可重复读和脏读。

                    SERIALIZABLE 幻读、不可重复读和脏读都不允许。

                    Oracle默认的隔离级别是READ COMMITTED。

                    幻读:数据发生新增。第一个事务对一个表中的所有数据进行了修改,

                               同时,第二个事务向这个表中插入一行新数据。那么,以后就会

                               发生操作第一个事务的用户发现表中还有没有修改的数据行,就

                               好象发生了幻觉一样。

                   不可重复读:数据发生修改由于一个事务的修改导致另外一个事务两次

                                        读到的数据不一致。如在一个事务内,多次读同一数据。

                                        在这个事务还没有结束时,另外一个事务也访问该同一数

                                        据。那么,在第一个事务中的两次读数据之间,由于第二

                                       个事务的修改,那么第一个事务两次读到的的数据可能是

                                       不一样的。 

                   脏读:读到了另外一个事务未提交的数据。如当一个事务正在访问数据,

                              并且对数据进行了修改,而这种修改还没有提交到数据库中,这

                              时,另外一个事务也访问这个数据,然后使用了这个数据。                               

     (2)Spring事务

            (a)Spring事务的原理

                     Spring事务的本质其实就是数据库对事务的支持,没有数据库的事务支持,

                     Spring是无法提供事务功能的。对于纯JDBC操作数据库,想要用到事务,

                     可以按照以下步骤进行:

                   (i)获取连接 Connection con = DriverManager.getConnection()

                   (ii)开启事务con.setAutoCommit(true/false);

                   (iii)执行CRUD

                   (iv)提交事务/回滚事务 con.commit() / con.rollback();

                   (v)关闭连接 conn.close();

                     使用Spring的事务管理功能后,我们可以不再写步骤(ii)和(iv)的代码,

                     而是由Spirng 自动完成。那么Spring是如何在我们书写的 CRUD 之前和之

                     后开启事务和关闭事务的呢?解决这个问题,也就可以从整体上理解

                     Spring的事务管理实现原理了。下面简单地介绍下,注解方式为例子

            (b)Spring 事务的传播

                     REQUIRED:业务方法需要在一个容器里运行。如果方法运行时,已经处

                                            在一个事务中,那么加入到这个事务,否则自己新建一个新

                                            的事务(默认,和SUPPORTS一起记)

                     SUPPORTS:该方法在某个事务范围内被调用,则方法成为该事务的一部

                                             分。如果方法在该事务范围外被调用,该方法就在没有事务

                                             的环境下执行(和默认分一类吧,暂叫它默认2吧)。 

                     REQUIRESNEW:总会发起一个新得事务。

                                                    不管是否存在事务,该方法总会为自己发起一个新的事

                                                    务。如果方法已经运行在一个事务中,则原有事务挂起,

                                                    新的事务被创建(新事务,零碎没组)。

                     NOT_SUPPORTED:声明方法不需要事务。如果方法没有关联到一个事务,

                                                        容器不会为他开启事务,如果方法在一个事务中被调

                                                        用,该事务会被挂起,调用结束后,原先的事务会恢

                                                        复执行(不需要事务,零碎没组)。

                     MANDATORY:该方法只能在一个已经存在的事务中执行,业务方法不能

                                                发起自己的事务。如果在没有事务的环境下被调用,容器

                                                抛出例外(必须要在有事务的环境中执行,和NEVER一

                                                起记)。                                       

                     NEVER:该方法绝对不能在事务范围内执行。如果在就抛例外。只有该方

                                     法没有关联到任何事务,才正常执行(必须要在没有有事务的环

                                     境中执行)。

                     NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中。如果

                                       没有活动事务,则按REQUIRED属性执行。它使用了一个单独

                                       的事务,这个事务拥有多个可以回滚的保存点。内部事务的回

                                       滚不会对外部事务造成影响。它只对

                                       DataSourceTransactionManager事务管理器起效。

    5.spring 常用标签

      (1)@Controller、@Service、@Respository,分别是Controller、Service、

               Dao的注解。

     (2)@Component

              @component就是说把这个类交给Spring管理。是一个泛化的概念,仅仅

              表示一个组件 (Bean) ,可以作用在任何层次。因为在持久层、业务层和控

              制层中,分别采用@Repository、@Service和@Controller对分层中的类进

              行注解,而用@Component对那些比较中立的类进行注解。

     (3)@Resource和@Autowired

                     两者均做bean注入时使用的,@Resource的作用相当于@Autowired。

                     @Resource是按name进行注入,而@Autowired是按type进行注入,

                     @Resource示例如下:

public class TestServiceImpl {

              @Resource(name="userDao")

              private UserDao userDao; // 用于字段上

              @Resource(name="userDao")

              public void setUserDao(UserDao userDao) { 

              this.userDao = userDao;

                                       注,将Resource放在set方法上更符合面向对象的思想,对set

                                       方法操作而不是直接对属性进行操作。

     (3)@PostConstruct 和 @PreDestroy 

              用于实现初始化和销毁bean之前进行的操作     

    6.Spring Bean的生命周期

       购写本节,参考文章:

       https://blog.csdn.net/w_linux/article/details/80086950

       https://blog.csdn.net/fuzhongmin05/article/details/73389779

     (1)最简单的说法,为了方便记忆(2)看一下,(2)才是重点

            (a)bean定义

                     在配置文件里面用<bean></bean>来进行定义。

            (b)bean初始化

                     有两种方式初始化:

                     在配置文件中通过指定init-method属性来完成

                     实现org.springframwork.beans.factory.InitializingBean接口

            (c)bean调用

                     有三种方式可以得到bean实例,并进行调用

            (d)bean销毁

                     销毁有两种方式

                     使用配置文件指定的destroy-method属性

                     实现org.springframwork.bean.factory.DisposeableBean接口

     (2)简单版,重点,面试的时候按照这个答

              

            (a)实例化bean对象(通过构造方法或者工厂方法,这里有点费解,为什么

                     没有通过setter方法)

            (b)设置对象属性(setter等)(依赖注入)

            (c)检查Aware接口,设置相关依赖。如果Bean实现了BeanNameAware接

                     口,spring将bean的id传给setBeanName()方法;如果Bean实现了

                     BeanFactoryAware接口,spring将调用setBeanFactory方法,将

                     BeanFactory实例传进来。

            (d)将Bean实例传递给Bean的前置处理器的

                     postProcessBeforeInitialization(Object bean, String beanname)方法

            (e)调用Bean的初始化方法。(初始化bean有两种方式,在配置文件中通过

                     指定init-method属性来完成和实现

                     org.springframwork.beans.factory.InitializingBean接口。图上有画)

            (f)将Bean实例传递给Bean的后置处理器的

                     postProcessAfterInitialization(Object bean, String beanname)方法使用

                     Bean。

            (g)使用。此时bean已经准备就绪,可以被应用程序使用了,他们将一直驻

                     留在应用上下文中,直到该应用上下文被销毁。

            (h)容器关闭之前,调用Bean的销毁方法(bean的销毁方法有两种:使用

                     配置文件指定的destroy-method属性和实现

                     org.springframwork.bean.factory.DisposeableBean接口。图上有画)

     (2)详细版,闲的蛋疼时候在看

        

               bean的生命周期流程图:

             

           

            (a)Spring对bean进行实例化,默认bean是单例;

            (b)Spring对bean进行依赖注入;

            (c)如果bean实现了BeanNameAware接口,spring将bean的id传给

                     setBeanName()方法;

            (d)如果bean实现了BeanFactoryAware接口,spring将调用setBeanFactory

                     方法,将BeanFactory实例传进来;如果bean实现了

                     ApplicationContextAware接口,它的setApplicationContext()方法将被调

                     用,将应用上下文的引用传入到bean中;

            (e)如果bean实现了BeanPostProcessor接口,它的

                     postProcessBeforeInitialization方法将被调用;

            (f)如果bean实现了InitializingBean接口,spring将调用它的

                    afterPropertiesSet接口方法,类似的如果bean使用了init-method属性声

                    明了初始化方法,该方法也会被调用;

            (g)如果bean实现了BeanPostProcessor接口,它的

                     postProcessAfterInitialization接口方法将被调用;

            (h)此时bean已经准备就绪,可以被应用程序使用了,他们将一直驻留在应

                     用上下文中,直到该应用上下文被销毁;

            (i)若bean实现了DisposableBean接口,spring将调用它的distroy()接口方

                    法。同样的,如果bean使用了destroy-method属性声明了销毁方法,则

                    该方法被调用;

    7.bean的作用域

       Spring Bean共有五种作用域,其中request、session、global session三种作用域

       仅在基于web的应用中使用(不必关心你所采用的是什么web应用框架),只能用

       在基于web的Spring ApplicationContext环境。

     (1)singleton

              当一个bean的作用域为singleton,那么Spring IoC容器中只会存在一个共享的

              bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返

              回bean的同一实例。

     (2)prototype

              Prototype作用域的bean会导致在每次对该bean请求(将其注入到另一个bean

              中,或者以程序的方式调用容器的getBean() 方法)时都会创建一个新的bean

              实例。根据经验,对所有有状态的bean应该使用prototype作用域,而对无状

              态的bean则应该使用 singleton作用域

     (3)request

              在一次HTTP请求中,一个bean定义对应一个实例;即每次HTTP请求将会有

              各自的bean实例, 它们依据某个bean定义创建而成。该作用域仅在基于web

              的Spring ApplicationContext情形下有效。

     (4)session

              在一个HTTP Session中,一个bean定义对应一个实例。该作用域仅在基于

              web的Spring ApplicationContext情形下有效。

     (5)global session

              global session作用域类似于标准的HTTP Session作用域,不过它仅仅在基

              于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念,

              它被所有构成某个 portlet web应用的各种不同的portlet所共享。在

              global session作用域中定义的bean被限定于全局portlet Session的生命周

              期范围内。如果你在web中使用global session作用域来标识bean,那么web

              会自动当成session类型来使用。

      8.Spring 注入方式

       (1)setter注入

       (2)构造器注入

       (3)静态工厂方法注入

       (4)实例工厂方法注入

    10.比较重要的一些面试题

     (1)BeanFactory 接口和 ApplicationContext 接口有什么区别 ?

            (a)ApplicationContext 接口继承BeanFactory接口,Spring核心工厂是

                     BeanFactory,BeanFactory采取延迟加载,第一次getBean时才会

                     初始化Bean,ApplicationContext是会在加载配置文件时初始化

                     Bean。
            (b)ApplicationContext是对BeanFactory扩展,它可以进行国际化处理、

                     事件传递和bean自动装配以及各种不同应用层的Context实现。开发

                     中基本都在使用ApplicationContext,web项目使用

                     WebApplicationContext ,很少用到BeanFactory。

     (2)spring配置bean实例化有哪些方式?

            (a)使用类构造器实例化(默认无参数)

            (b)使用静态工厂方法实例化(简单工厂模式)

            (c)使用实例工厂方法实例化(工厂方法模式)

    11.Spring Quartz、Spring Task、elastic-job

       (1)Spring Quartz的特点: 

                https://blog.csdn.net/mseeworld/article/details/53331197

      (2)当当的elastic-job
二.Spring MVC

    1.Spring MVC原理

     (1)概述

              Spring MVC是基于Servlet的。

              若基于某个框架开发一个模型2的应用程序,我们要负责编写一个

              Dispatcher Servlet(如果忘记该例子书上找)。其中Dispatcher Servlet必须能

              够做如下事情:

            (a)根据URI调用相应的action。

            (b)实例化正确的控制器类

            (c)根据请求参数来构造表单bean

            (d)调用控制器对象的相应方法

            (e)转向到一个视图(JSP页面)

              Spring MVC是一个包含了Dispatcher Servlet的MVC框架,它调用控制器方法

              并转发到视图。这是使用Spring MVC的第一个好处:不需要编写Dispatcher

              Servlet。以下是Spring MVC具有的能加速开发的功能列表:

            (a)Spring MVC提供了一个Dispatcher Servlet,无需额外开发

            (b)Spring MVC实例化控制器,并根据用户输入来构造bean。

            (c)Spring MVC可以自动绑定用户输入,并正确转换数据类型。例如

                     Spring MVC能自动解析字符串,并设置float或decimal类型的属性

            (d)Spring MVC支持国际化和本地化。支持根据用户区域显示多国语言。

            (e)Spring MVC支持多种视图技术。如JSP、Velocity和FreeMarker。

            (f)Spring MVC提供校验用户输入功能。

            (g)Spring MVC中使用基于XML的配置文件,可以编辑,二无需重新编译应

                       用程序。

            (h)Spring MVC是Spring框架的一部分,可以利用Spring提供的其它能力。

     (2)Spring MVC原理和工作流程

              

            (a)简单版

                   (i)客户端请求提交到DispatcherServlet

                   (ii)由DispatcherServlet控制器查询一个或多个HandlerMapping,找到

                            处理请求的Controller

                   (iii)DispatcherServlet将请求提交到Controller

                   (iv)Controller调用业务逻辑处理后,返回ModelAndView

                   (v)DispatcherServlet查询一个或多个ViewResoler视图解析器,找到

                            ModelAndView指定的视图

                   (vi)视图负责将结果显示到客户端

            (b)完整版

                   (1)发起请求到前端控制器(DispatcherServlet);

                   (2)前端控制器请求HandlerMapping查找Handler,可以根据xml配置、

                            注解进行查找;

                   (3)处理器映射器HandlerMapping向前端控制器返回Handler;

                   (4)前端控制器调用处理器适配器去执行Handler;

                   (5)处理器适配器去执行Handler;

                   (6)Handler执行完成给适配器返回ModelAndView;

                   (7)处理器适配器向前端控制器返回ModelAndView(是springmvc框架

                            的一个底层对象,包括Model和View);

                   (8)前端控制器请求视图解析器去进行视图解析,根据逻辑视图名称解

                            析真正的视图(jsp...);

                   (9)视图解析器向前端控制器返回View;

                   (10)前端控制器进行视图渲染,视图渲染就是将模型数据(在

                            ModelAndView对象中)填充到request域中。

                   (11)前端控制器向用户响应结果。

    2.Spring MVC功能介绍

     (1)DispatcherServlet

              org.springframework.web.servlet.DispatcherServlet。要使用这个Servlet需要

              它配置在web.xml中

  <!--  Spring MVC 的Servlet,它将加载WEB-INF/springDispatcherServlet-servlet.xml 的配置文件,以启动Spring MVC模块-->    
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

 

                        DispatcherServlet会使用Spring MVC诸多默认组件,此外,初始化时它

                       会寻找一个在应用程序WEB-INF目录下的配置文件,该配置文件的命名

                       规则如下:

                              servletName-servlet.xml

                       其中,servletName是web.xml中DispatcherServlet的名称,按上例,应

                       该为:SpringMVC-servlet.xml(上文中servlet的名字是springmvc,是否

                       不区分大小写有机会验证一下,一般都是写成spring-mvc.xml)。此外也

                       可以把Spring MVC的配置文件放到应用程序目录的任何地方,用servlet

                       的<init-param>指定,示例如下:

<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:spring/abc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

                       其中“classpath*:spring/abc.xml”,也可以换成绝对路径。

     (2)Controller接口

              在Spring2.5以前,开发一个控制器的唯一方法是实现

              org.springframework.web.servlet.mvc.Controller接口,这个接口公开了一个

              handleRequest方法。下面是该方法的签名:

public ModelAndView handleRequest(HttpServletRequest request,HttpServletResponse response)throws Exception;  

              Controller接口的实现类只能处理一个动作,而一个基于注解的控制器可以同时

              支持多个请求处理动作,并且无需实现任何接口,使用@Controller注解。

     (3)View Resolver(视图解析器)

              Spring MVC中的视图解析器负责解析视图,可以通过在配置文件中定义一个

              View Resolver来配置视图解析器,示例如下:

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property key="prefix" value="/WEB-INF/jsp/"/>
    <property key="suffix" value=".jsp" />
</bean> 

              通过上面的方法就可以将视图路径由原来的“/WEB-INF/jsp/myPage.jsp”改写成

              “myPage”。ViewResolver接口其内部只有一个接口方法,具体如下:

View resolveViewName(String viewName, Locale locale) throws Exception;

              由上可知其是通过解析ViewName来得到View视图对象。

              注:InternalResourceViewResolver只是视图解析器中的一种,JSP+JSTL这一

                     套用它,但是其它视图如Fremakker、velocity。

     (4)Spring MVC支持的返回方式

              * ModelAndView

              * Model

              * ModelMap

              * Map

              * View

              * String

              * void

            (a)Model和ModelAndView

                   (i)Model

                           Model是每次请求中都存在的默认参数,利用其addAttribute()方法即可

                           将服务器的值传递到jsp页面中;Model的生命周期只是一个请求的处理

                           过程,请求处理完,Model也就销毁了。

                   (ii)ModelAndView

                            包含model和view两部分,使用时需要自己实例化,利用ModelMap用

                            来传值,也可以设置view的名称

                            例一,使用Model传值

 public String getAllBooks(Model model){  
        logger.error("/list-books");  
        List<Book> books= bookService.getAllBooks();  
        model.addAttribute("books", books);  
        return "BookList";  
 }

                            例二,使用ModelAndView来传值。

                                       使用ModelAndView传递值有两种方法,不同方法在jsp页面的

                                       取值方式不同,同时设置了view的名称

public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response,
                                         Object handler, Exception ex) {
        LibraryException le=null;
        if(ex instanceof LibraryException){
            le=(LibraryException)ex;
        }else{
            le=new LibraryException("系统未知异常!");
        }
 
        ModelAndView modelAndView=new ModelAndView();
        modelAndView.addObject("exception",le.getMessage());
        modelAndView.getModel().put("exception",le.getMessage());
        modelAndView.setViewName("error");
 
        return modelAndView;
 }

                         jsp中${requestScope.exception1}可以取出exception1的值;

                         jsp中${exception2}可以取出exception2的值

                         关于Model和ModelAndView的区别想进一步了解可以查看博客:

                         https://blog.csdn.net/wangmeng951011/article/details/53121483

                         通过ModelAndView构造方法可以指定返回的页面名称,也可以通过

                         setViewName()方法跳转到指定的页面。上面的例子是通过

                         setViewName()方法指定跳转页面,通过构造函数指定跳转页面示例

                         如下:             

@RequestMapping("/hello")
public ModelAndView helloWorld() { 
    String message = "Hello World, Spring 3.x!";
    return new ModelAndView("hello", "message", message);
}

            (b)Map

@RequestMapping("/demo2/show") 
public Map<String, String> getMap() { 
  Map<String, String> map = new HashMap<String, String>(); 
  map.put("key1", "value-1"); 
  map.put("key2", "value-2"); 
  return map; 
} 

                         在jsp页面中可直通过${key1}获得到值, map.put()相当于

                         request.setAttribute方法。

            (c)View

                     可以返回pdf excel等,暂时没详细了解。

            (d)String

                     指定返回的视图页面名称,结合设置的返回地址路径加上页面名称后缀

                     即可访问到。

                     注意:如果方法声明了注解@ResponseBody ,则会直接将返回值输出

                                到页面。

@RequestMapping(value="/showdog")
public String hello1(){
        return "hello";
}
@RequestMapping(value="/print")
@ResponseBody
public String print(){
  String message = "Hello World, Spring MVC!";
  return message;
}

                     返回json的例子(使用Jackson):

@RequestMapping("/load1")
@ResponseBody
public String load1(@RequestParam String name,@RequestParam String password) throws IOException{
        System.out.println(name+" : "+password);  
        //return name+" : "+password;
        MyDog dog=new MyDog();
        dog.setName("小哈");dog.setAge("1岁");dog.setColor("深灰");
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonString=objectMapper.writeValueAsString(dog);
        System.out.println(jsonString);
        return jsonString;
}

            (d)如果返回值为空,则响应的视图页面对应为访问地址

@RequestMapping("/index")
public void index() {
        return;
}

                     对应的逻辑视图名为"index"。

     (5)重定向和转发

            (a)转发,较简单,略

            (b)重定向

                     Spring3.1版本开始使用Flash属性进行转发,并且还需要做下面两件事

                   (i)在Spring MVC配置文件中需要添加一个<annotation-driven/>元素

                   (ii)添加一个

                            org.springframework.web.servlet.mvc.support.RedirectAttributes

                            类型的参数。

                     例子如下:  

@RequestMapping(value="/testa", method=RequestMethod.GET)
 public String inputData(){
  return "testa"; //Spring框架找到对应的View并渲染
 }

 @RequestMapping(value="/testa", method=RequestMethod.POST)
 public String outputData(HttpServletRequest request, RedirectAttributes redirectAttributes){
  String userName = request.getParameter("name");
  String password = request.getParameter("pwd");
  request.setAttribute("name", userName);
  request.setAttribute("pwd", password);
  //重定向到 /testb 的Controller方法(即outputDataY)上
  //重定向传递参数的两种方法
  redirectAttributes.addAttribute("name", userName);
  redirectAttributes.addFlashAttribute("pwd", password);

  return "redirect:/testb"; 
 }

 @RequestMapping(value="/testb", method=RequestMethod.POST)
 public String outputDataX(HttpServletRequest request){
  return "testb";
 }

 @RequestMapping(value="/testb", method=RequestMethod.GET)
 public String outputDataY(HttpServletRequest request){
  String userName = request.getParameter("name");
  request.setAttribute("name", userName);
  return "testb";
 }

     (6)转换器和格式化(Converter和Formatter)

              在学习Converter和Formatter之前需要我们先了解<mvc:annotation-driven/>

              和<context:component-scan/>的做用

              <mvc:annotation-driven/>:它告知Spring,我们启用Spring MVC的注解驱

                                                          动。它为我们注册了很多bean,但这里我们主

                                                          要说两个:RequestMappingHandlerMapping和

                                                          RequestMappingHandlerAdapter。第一个是

                                                          HandlerMapping的实现类,它会处理

                                                          @RequestMapping 注解,并将其注册到请求映

                                                          射表中。详细讲解可以查看:

                                                          https://blog.csdn.net/lovesomnus/article/details/49801593

              <context:component-scan/>:是告诉Spring 来扫描指定包下的类,并注册

                                                              被@Component,@Controller,@Service,

                                                              @Repository等注解标记的组件

            (a)Converter

                     Converter是Spring3中引入的一项比较特殊的功能,其实就是一个转换

                     器,可以把一种类型转换为另一种类型。尤其是在web项目中比较常见,

                     可以对接口的入参做校验,把前端的入参的类型转换后为后端可以使用

                     的类型。如常常用来做类型转换、字符串去空、日期格式化等。在

                     Spring3之前进行类型转换都是使用PropertyEditor,使用

                     PropertyEditor的setAsText()方法可以实现String转向特定的类型,但是

                     它的最大的一个缺陷就是只支持String转为其他类型。

                     Spring中的三种类型转换接口分别为:

                     * Converter接口:使用最简单,但是不太灵活;

                     * ConverterFactory接口:使用较复杂,稍微灵活一点;

                     * GenericConverter接口:使用最复杂,也最灵活;

                     但是此次只学习Converter。下面来讲解怎么使用:

                   (i)实现org.springframework.core.convert.converter.Converter接口

                           Converter接口定义:

public class MyDateConverter implements Converter<String,Date> {

    @Override
    public Date convert(String source) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return sdf.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
}

                           补充一下Converter接口的说明,其定义如下:

package org.springframework.core.convert.converter;
 
public interface Converter<S, T> {
    T convert(S var1);
}

                           其中S表示源类型,T表示目标类型,该接口支持泛型。

                   (ii)配置bean

<!-- 日期转换工厂 -->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="com.converter.MyDateConverter">
                    <constructor-arg type="java.lang.String" value="yyyy-MM-dd"></constructor-arg>
                </bean>
            </list>
        </property>
    </bean>

                           注意要给annotation-driven元素的conversion-service属性赋上bean

                           名称:

<mvc:annotation-driven conversion-service="myDateConverter">
</mvc:annotation-driven>

                           注册这个Converter服务,然后对于所有使用了@RequestMapping

                           注解的方法参数,都可以自动将String按规定的格式转换为Date类

                           型。

                           完整的一个配置样例如下:

<?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:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
        ">
    <context:component-scan base-package="controller"/>
    <context:component-scan base-package="Service"/>
    <!--
     <mvc:annotation-driven>元素注册用于支持基于注解的控制器的请求处理方法的Bean对象。
        详解:https://my.oschina.net/HeliosFly/blog/205343
    -->
    <mvc:annotation-driven conversion-service="conversionService"/>

    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="converter.MyConverter">
                    <constructor-arg type="java.lang.String" value="MM-dd-yyyy"/>
                </bean>
            </list>
        </property>
    </bean>
</beans>

 

            (b)Formatter

                     Formatter就像Converter一样,也是将一种类型转换成另一种类型。但

                     是Formatter更适合Web层,而Converter则可以用在任意层种。为了转

                     换Spring MVC应用程序表单种的用户输入,始终应选择Formatter而不

                     是Converter。

                             Formatter的使用方式,通过例子来讲解。

                   (i)首先编写一个实现org.springframework.format.Formatter接口的

                           Java类,该类是将String 转换成Date。     

package app06b.formatter
import org.springframework.format.Formatter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

public class DateFormatter implements Formatter<Date>{
    private String datePattern;
    private SimpleDateFormat dateFormat;

    public DateFormatter(String datePattern) {
        this.dateFormat = dateFormat;
        dateFormat = new SimpleDateFormat(datePattern);
        dateFormat.setLenient(false);
    }
    public Date parse(String s, Locale locale) throws ParseException {
        try {
            SimpleDateFormat dateFormat = new SimpleDateFormat(datePattern);
            dateFormat.setLenient(false);
            return dateFormat.parse(s);
        } catch (ParseException e) {
            throw new IllegalArgumentException("invalid date format. Please use this pattern\"" + datePattern + "\"");
        }
    }

    public String print(Date date, Locale locale) {
        return dateFormat.format(date);
    }
}

                     这里插入一下对Formatter接口的说明:

public interface Formatter<T> extends Printer<T>, Parser<T> {
}
public interface Printer<T> {
    String print(T var1, Locale var2);
}
public interface Parser<T> {
    T parse(String var1, Locale var2) throws ParseException;
}

                     parse方法利用指定的Locale将一个String解析成目标类型。print方法

                     相反,它是返回目标对象的字符串表示法。

                   (ii)配置Formatter

                            为了使用Spring MVC应用程序中使用Formatter,需要在配置文

                            件中添加一个conversionService bean。Bean的类名称必须

                            org.springframework.format.support.

                            FormattingConversionServiceFactoryBean。这个bean可以用一

                            个formatters属性注册Formatter,用一个converters属性注册

                            Converter。下面bean声明注册了上面DateFormatter。

<?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:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
        ">
    <context:component-scan base-package="controller"/>
    <context:component-scan base-package="Service"/>
    <!--
     <mvc:annotation-driven>元素注册用于支持基于注解的控制器的请求处理方法的Bean对象。
        详解:https://my.oschina.net/HeliosFly/blog/205343
    -->
    <mvc:annotation-driven conversion-service="conversionService"/>

    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/"/>
        <property name="suffix" value=".jsp"/>
    </bean>    
    <!--需要配置此项来扫描Formatter-->
    <context:component-scan base-package="app06b.formatter"/>
    <bean id="formatterConversionService" 
          class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="formatters">
            <set>
                <bean class="formatter.DateFormatter">
                    <constructor-arg type="java.lang.String"
                                     value="MM-dd-yyyy"/>
                </bean>
            </set>
        </property>
    </bean>
</beans>

                            注意,需要为这个Formatter添加component-scan元素和给

                            annotation-driven元素的conversion-service属性赋上bean名称。

     (7)文件上传

              文件上传方式有Servlet上传文件、ApacheCommonsFileUpload上传文件

            (apache)和MultipartFile接口(Spring MVC)。但是无论采用哪一种方

              式上传,前端的写法都一样。文件上传时需要注意两点:一是表单提交

              Form内容enctype必须加上,且内容必须是multipart/form-data,表示二

              进制方式提交二是提交方式必须是post。

              单文件上传:

	<form action="${pageContext.request.contextPath}/fileUpload" method="POST" enctype="multipart/form-data">
		username:<input type="text" name="username" /><br>
		上传文件:<input type="file" name="fileName" /><br>
		   <input type="submit" value="文件上传" /><br>
	</form>

              多文件上传(仅限于H5):

	<form action="${pageContext.request.contextPath}/fileUpload" method="POST" enctype="multipart/form-data">
		username:<input type="text" name="username" /><br>
		上传文件:<input type="file" name="fileName" multiple/><br>
		   <input type="submit" value="文件上传" /><br>
	</form>

              其中<input type="file" name="fileName" multiple/>等价于如下代码:

<input type="file" name="fileName" multiple="multiple"/>
<input type="file" name="fileName" multiple=""/>

            (a)MultipartFile

                     Spring MVC会将上传文件绑定到MultipartFile对象中,该对象提供

                     了获取上传文件内容,文件名等方法。通过transferTo()方法还可以

                     将文件存储到硬件中。

                     MultipartFile常用方法如下:

                     * bye[] getBytes()  :获取文件数据

                     * String getContentType()  :获取文件MIME类型

                     * InputStream getIputStream()  :获取文件流

                     * String getName()  :获取表单中文件组件的名字

                     * String getOriginalFilename()  :获取上传文件的原名

                     * boolean isEmpty()  :是否有上传的文件

                     * void transferTo(File dest)  :将文件保存到一个目标文件中

                     下面通过例子讲解MultipartFile怎么使用(这只是个单文件上传的例子,多文

                     件上传,自行百度)

                    (i)创建一个项目,导入相应的jar包,包括Apache的Commons FileUpload

                            的jar包。

                    (ii)编写web.xml和springmvc-config.xml

                             web.xml

<!-- 配置前端控制器 -->
  <servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springmvc-config.xml</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>

                             springmvc-config.xml

<!-- spring可以自动去扫描base-package下面的包或者子包下面的java类 如果扫描到有spring相关注解的类,则吧这个类注册为spring的bean -->
    <context:component-scan base-package="com.dj.controller" />
    <!-- 配置MultipartResolver -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 上传文件大小限制,单位为字节-10Mb -->
        <property name="maxUploadSize">
            <value>10485760</value>
        </property>
        <!-- 请求的编码格式 -->
        <property name="defaultEncoding">
            <value>UTF-8</value>
        </property>
        <property name="maxInMemorySize">
            <value>4096</value>
        </property>
    </bean>
    <!-- 默认装配 -->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!-- 视图解析器 -->
    <bean id="viewResolver"
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix">
            <value>/</value>
        </property>
        <!-- 后缀 -->
        <property name="suffix">
            <value>.jsp</value>
        </property>
    </bean>

                    (iii)编写一个上传文件的实体类

package com.test;

public class User implements java.io.Serializable{

	private String username;
	//对应上传文件的file,类型为multipartfile,上传文件会自动绑定到image属性中
	private MultipartFile image;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public MultipartFile getImage() {
		return image;
	}
	public void setImage(MultipartFile image) {
		this.image = image;
	}
	
}

                    (iv)编写Controller

@Controller
public class FileUploadController {

    /**
     * 动态跳转页面
     * @param pagename
     * @return
     */
    @RequestMapping(value="/{pagename}")
    public String toPage(@PathVariable String pagename){
        return pagename;
    }
    
    @RequestMapping(value="regist")
    public String regist(HttpServletRequest request,
            @ModelAttribute User user,Model model) throws Exception, IOException{
        if(!user.getImage().isEmpty()){
            //文件上传路径
            String path = request.getServletContext().getRealPath("/images/");
            //上传文件名
            String filename = user.getImage().getOriginalFilename();
            File filepath = new File(path, filename);
            //判断路径是否存在
            if(!filepath.getParentFile().exists()){
                filepath.getParentFile().mkdirs();
            }
            //将上传文件保存到一个目标文件中
            user.getImage().transferTo(new File(path+File.separator+filename));
            model.addAttribute("user", user);
            return "userinfo";
        }
                return "error";
        
    }
}

                    (v)编写注册页面和显示信息页面

<form action="regist" method="post" enctype="multipart/form-data">
    用户名:<input type="text" name="username"/><br>
    请上传头像:<input type="file" name="image"><br>
    <input type="submit" vaue="注册">
</form>

            (c)ApacheCommonsFileUpload

                    对于低于Servlet3.0版本,可以使用该方式上传。

                    有些博客说必须使用POST提交,有些博客说可以使用GET提交,具体哪个

                    对,不知道,以后写代码时统一使用POST提交。

                    具体怎么用看两篇文章:

                    https://blog.csdn.net/qq_24053795/article/details/50608283(这篇使用的是

                    GET提交)

                    https://blog.csdn.net/java_raylu/article/details/73691459(这篇是使用POST

                    提交)

            (b)Servlet上传文件

                     只有Servlet3.0及以上版本,可以使用Servlet上传文件

                     具体查看:https://www.cnblogs.com/xdp-gacl/p/4224960.html

     (8)文件下载

              Spring MVC有提供,用到的时候自行百度吧。

     (9)Spring MVC国际化和本地化

            (a)了解一下Spring MVC的语言解析器,它有三种语言解析器

                    (i)Header resolver:通过解析客户端请求头信息中心的accept-language(该

                                                         项其实是浏览器的设置),来获取用户需要的国际化语

                                                         言。详见=AcceptHeaderLocaleResolver

                    (ii)Cookie resolver:通过解析客户端上Cookie指定的locale,来获取用户需要

                                                         的国际化信息。详见=CookieLocaleResolver

                    (iii)Session resolver:通过解析客户端请求域中的loacle信息,来获取需要的

                                                            国际化信息,并存储在httpSession中。

                                                            详见=SessionLocaleResolver

            (b)具体例子,查看:https://www.cnblogs.com/caoyc/p/5637865.html

     (10)Spring MVC和Spring的线程安全问题

              (a)当Spring MVC是单例时,Controller线程不安全,所以应避免在controller中定

                       义实例变量。

                       解决办法:

                     (i)在Controller中使用ThreadLocal变量

                     (ii)在spring配置文件Controller中声明 scope="prototype",每次都创建新的

                              controller所在在使用spring开发web时要注意

              (b)Spring中Dao和Service都是单例,但是线程安全,因为其使用了

                       ThreadLocal。

                       详细查看:https://blog.csdn.net/liou825/article/details/17363265             

     (11)Spring MVC和Spring整合

            (a)Spring和Spring MVC父子容器

                     虽然springMVC和spring有必然的联系,但是他们的区别也是有的:

                   (i)springmvc和spring都是容器,容器就是管理bean的地方。但springmvc

                           就是管理controller对象的容器,spring就是管理service和dao的容器。

                           所以我们在springmvc的配置文件里配置的扫描路径就是controller的路

                           径,而spring的配置文件里自然配的就是service和dao的路径。

                   (ii)spring容器和springmvc容易的关系是父子容器的关系。spring容器是父

                            容器,springmvc是子容器。在子容器里可以访问父容器里的对象,但

                            是在父容器里不可以访问子容器的对象,说的通俗点就是,在controller

                            里可以访问service对象,但是在service里不可以访问controller对象。

                   (iii)Spring容器是由ServletContext创建;Spring MVC容器是由DispatcherServlet创建

                             创建Spring容器代码:

<!-- 配置spring ioc容器 -->
<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:config/applicationContext.xml</param-value>
</context-param>

                             创建Spring MVC容器代码:

<!-- 配置springmvc 的DispatcherServlet -->
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:config/spring-mvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

            (b)Spring和Spring MVC整合例子

                   (i)构建环境

                           * 导包,需要如下包:

                   

                           * 构建项目:

                           

                   (ii)spring-mvc.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:mvc="http://www.springframework.org/schema/mvc" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd  
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">
 
	<!-- 配置自动扫描包 -->
	<context:component-scan base-package="com.ssh" />
	<mvc:annotation-driven />
 
	<!-- 配置视图解析器 -->
	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/pages/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>
</beans>  

                   (iii)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:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">
 
	<!-- 配置自动扫描的包 -->
	<context:component-scan base-package="com.ssh">
		<!-- 扫描时跳过 @Controller 注解的JAVA类(控制器) -->
		<context:exclude-filter type="annotation"
			expression="org.springframework.stereotype.Controller" />
	</context:component-scan>
</beans>  

                   (iv)web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="3.0">
	<display-name>ssh</display-name>
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
 
	<!-- 配置spring ioc容器 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:config/applicationContext.xml</param-value>
	</context-param>
 
	<!-- Bootstraps the root web application context before servlet initialization -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
 
	<!-- 配置springmvc 的DispatcherServlet -->
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:config/spring-mvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
 
	<!-- Map all requests to the DispatcherServlet for handling -->
	<servlet-mapping>
		<servlet-name>dispatcherServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
 
	<filter>
		<filter-name>CharacterEncodingFilter</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>CharacterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
</web-app>

                   (v)代码

                            * UserController

package com.ssh.controller;
 
import javax.servlet.http.HttpServletRequest;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
import com.ssh.service.UserService;
 
@Controller
@RequestMapping("/user")
public class UserController {
 
	@Autowired
	private UserService userService;
 
	@RequestMapping(value = "save")
	public String save(HttpServletRequest request) {
		String username = request.getParameter("username");
		String password = request.getParameter("password");
		System.out.println(username + " " + password);
		System.out.println("controller save...");
 
		userService.save();
		return "success";
	}
}

                            * UserService:

package com.ssh.service;
 
public interface UserService {
	void save();
}

                            * UserServiceImpl:

package com.ssh.service;
 
import org.springframework.stereotype.Service;
 
@Service
public class UserServiceImpl implements UserService {
 
	@Override
	public void save() {
		System.out.println("userservice save...");
	}
}

                            * add.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
	pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
	<h1>添加用户</h1>
	<form action="user/save" method="post">
		用户 <input type="text" name="username" /><br /> 密码 <input type="text"
			name="password" /><br /> <input type="submit" value="添加">
	</form>
 
</body>
</html>
</html>

    3.Spring MVC注解

     (1)@Controller

              org.springframework.stereotype.Controller。用来指示Spring类的实例是一个控

              制器。Spring使用扫描机制来找到应用程序中所有基于注解的控制器类。为了保

              证Spring能找到你的控制器,需要完成两件事情。首先,在Spring MVC的配置

              文件中声明spring-context,如下所示:

<beans
   ...
   xmlns:context="http://www.springframework.org/schema/context"
   ...
>

              其次,需要应用<component-scan/>元素,如下所示:

<context:component-scan base-package="xxx.xxx.controller" />

     (2)@RequestMapping注解

              org.springframework.web.bind.annotation.RequestMapping,可以使用

              @RequestMapping注解方法和类。下面是一个使用@RequestMapping注解方

              法的控制器类:

@Controller
public class AppointmentsController {
    @RequestMapping("/bb")
    public String get() {
        return "consumerForm";
    }
 
 
}

              使用@RequestMapping注解的value属性将URI映射到方法上。这样我们就可以

              使用如下URI访问AppointmentsController方法:

              http://domain/context/bb

              下面是一个使用@RequestMapping注解方法的控制器类:

@Controller
@RequestMapping("/aa")
public class AppointmentsController {
    @RequestMapping("/bb")
    public String get() {
        return "consumerForm";
    }
 
 
}

              我们将使用如下URI访问AppointmentsController方法:

              http://domain/context/bb

              因为value是@RequestMapping的默认属性,因此,若只有唯一的属性,则可以

              省略属性名称。换句话说,如下两个标注含义相同。

@RequestMapping("/aa")
@RequestMapping(value="/aa")

              但是超过一个属性就必须写value属性名称,如下两个例子:

              例一:

@Controller
@RequestMapping(value="/aa",method=RequestMethod.POST)
public class AppointmentsController {
    @RequestMapping("/bb")
    public String get() {
        return "consumerForm";
    }
 
 
}

              例二:

@Controller
@RequestMapping(value="/aa",method = {RequestMethod.POST, RequestMethod.GET})
public class AppointmentsController {
    @RequestMapping("/bb")
    public String get() {
        return "consumerForm";
    }
 
 

     (3)@RequestBody、@ResponseBody、

              @RequestBody

              简介:@RequestBody 注解则是将 HTTP 请求正文插入方法中,使用适合的

                         HttpMessageConverter 将请求体写入某个对象。在使用Spring MVC

                         时,其主要作用是将POST请求中的JSON或XML绑定到Controller方法

                         的参数中(JavaBean)(一般用来处理POST请求中非

                         Content-Type: application/x-www-form-urlencoded的数据)。

                         关于Content-Type查看博客:

                         https://blog.csdn.net/qq32933432/article/details/80817250

                         https://www.cnblogs.com/tugenhua0707/p/8975121.html

                         关于@RequestBody不处理GET请求的说明:

                         其实在一般的情况下,GET请求是不可以用@RequestBody来接收参数

                         的。一般情况指的是请求由浏览器或者类似于POSTMAN这样的测试工

                         具发出,我们都知道,Http请求包含请求头和请求体,如果发出的请求

                         中请求体为空,那么使用@RequestBody注解来获取参数肯定是徒劳的,

                         所以在这种情况下,GET与@ReqestBody配合使用是有问题的。 此段

                         源于博客:https://blog.csdn.net/qq_28411869/article/details/81285810   

                         关于HTTP请求方式和Content-Type说明:

                         * GET,POST请求方式,需要判断content-type是何种数据类型:

                            content-type : multipart/form-data:

                            这种格式使用@RequestBody处理不了。

                            content-type : application/x-www-form-urlencoded:

                            form表单形式提交的数据格式,可以使用@RequestBody,也可以使

                            用其他注解例如@RequestParam, @ModelAttribute进行接收。

                            content-type : 其他数据格式:

                            必须使用@RequestBody进行接收。

                         * PUT请求方式,需要判断content-type是何种数据类型:

                           content-type : application/x-www-form-urlencoded:

                           必须使用@RequestBody

                           content-type : multipart/form-data:

                           @RequestBody处理不了

                           content-type : 其他数据格式: 

                           必须使用@RequestBody进行接收。

              作用:

                       该注解用于读取Request请求的body部分数据,使用系统默认配置的

                       HttpMessageConverter进行解析,把相应的数据绑定到要返回的对象

                       上,然后再把HttpMessageConverter返回的对象数据绑定到controller

                       中方法的参数上。

              注:

                       在一些特殊情况@requestBody也可以用来处理content-type类型为

                       application/x-www-form-urlcoded的内容,只不过这种方式不是很常用,

                       在处理这类请求的时候,@requestBody会将处理结果放到一个

                       MultiValueMap<String,String>中,这种情况一般在特殊情况下才会使用,

                       例如jQuery easyUI的datagrid请求数据的时候需要使用到这种方式、小型

                       项目只创建一个POJO类的话也可以使用这种接受方式。

                       下面的示例,只有示例二、三是常用的,其它不怎么常用,有兴趣可以研

                       究一下。https://blog.csdn.net/qq_34500957/article/details/80523200中提

                       到的一些用法,我的博客中并没有指定。

              示例一,前台传Json,属性绑定到参数上:

                      ajax代码:

 $.ajax({
        url:"/login",
        type:"POST",
        data:'{"userName":"admin","pwd","admin123"}',
        content-type:"application/json charset=utf-8",
        success:function(data){
          alert("request success ! ");
        }
    });

                      Controller代码:

@requestMapping("/login")
public void login(@requestBody String userName,@requestBody String pwd){
  System.out.println(userName+" :"+pwd);
}

              示例二,前台传Json,属性绑定到JavaBean:

                      ajax代码:

function loginAction() {

    // 获取用户输入的账号和密码
    var name = $('#count').val();
    var password = $('#password').val();

    $.ajax({
        url : 'account/login.do',
        type : 'post',
        // data对象中的属性名要和服务端控制器的参数名一致 login(name, password)
        data : {
            'name' : name,
            'password' : password
        },
        dataType : 'json',
        success : function(result) {
            if (result.state == 0) {
                // 登录成功,设置cookie并跳转edit.html
                addCookie('userId', result.data.id);
                addCookie('nick', result.data.nick);
                location.href = 'edit.html';
            } else {
                // 登录失败
                var msg = result.message;
                $('#sig_in').next().html(msg);
                $('#sig_in').next().css("color", "red");
            }
        },
        error : function(e) {
            alert("系统异常");
        }
    });
    $('#password').val("");
}

                      Java代码:

@RequestMapping("/login.do")
@ResponseBody
public Object login(@RequestBody User loginUuser, HttpSession session) {
   user = userService.checkLogin(loginUser);
   session.setAttribute("user", user);
   return new JsonResult(user);
}

              示例三,前台传Json数组对象,参数绑定到数组

                      前端代码:

<script type="text/javascript">  
    $(document).ready(function(){  
     $.ajax({
         type:'POST',
         url:'<%=path%>/user/ceshi.do',
	 dataType:"json",      
	 contentType:"application/json",   
	 data:JSON.stringify([{id:"1",name:"cehshi1"},{id:"2",name:"ceshi2"}]),
         success:function(){			
	 }
    });
</script>

                      Java代码:

@RequestMapping(value = "/ceshi", method = {RequestMethod.POST }) 
@ResponseBody
public void ceshi(@RequestBody User[] users){
	for (User user : users) {
	System.out.println(user.getId());
	}
}

              示例四,前台传对象数组,参数绑定到List

                      ajax代码:

var testList=[];
var user={};
user.id=1;
user.name='jack';
testList.push(user);
var user2={};
user2.id=2;
user2.name='tom';
testList.push(user2);
$.ajax({
    // headers必须添加,否则会报415错误
    headers: {
        'Accept': 'application/json',
        'Content-Type': 'application/json'
    },
  type: 'POST',
  dataType: "json", //表示返回值类型,不必须
  data: JSON.stringify(testList),
  url: '/test/postList',
  success: function(){
      alert('success');
  }
  
});

                      Java代码:

Controller:

@RequestMapping("/postList")
    @ResponseBody
    public String postList(@RequestBody List<TestL> testL){
        System.out.println(testL);
        return null;
    
 }

JavaBean:

public class TestL {
    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;
    }
}

              @RequestParam

              用来处理Content-Type: 为 application/x-www-form-urlencoded编码的内容。

            (Http协议中,如果不指定Content-Type,则默认传递的参数就是

              application/x-www-form-urlencoded类型)。在实际应用中,通常用它来处理GET

              请求,但是@RequestParam是可以处理GET请求和POST请求的(处理POST请求

              没实验过,使用时应该谨慎)。@RequestParam可以接受简单类型的属性,也可

              以接受对象类型。  实质是将Request.getParameter() 中的Key-Value参数Map利用

              Spring的转化机制ConversionService配置,转化成参数接收对象或字段。

              @RequestParam,有三个属性:

              * value:请求参数名(必须配置)

              * required:是否必需,默认为 true,即 请求中必须包含该参数,如果没有包含,

                                 将会抛出异常(可选配置)。

              * defaultValue:默认值,如果设置了该值,required 将自动设为 false,无论你是

                                        否配置了required,配置了什么值,都是 false(可选配置)

               下面开始看些例子:

                      前端代码:

<form action="/gadget/testRequestParam" method="post">    
     参数inputStr:<input type="text" name="inputStr">    
     参数intputInt:<input type="text" name="inputInt">    
</form>  

                      Java代码:

@RequestMapping("testRequestParam")    
   public String filesUpload(@RequestParam String inputStr, HttpServletRequest request) {    
    System.out.println(inputStr);  
      
    int inputInt = Integer.valueOf(request.getParameter("inputInt"));  
    System.out.println(inputInt);  
      
    // ......省略  
    return "index";  
   } 

                      可以对传入参数指定参数名:

// 下面的对传入参数指定为aa,如果前端不传aa参数名,会报错  
@RequestParam(value="aa") String inputStr  

                      错误信息: 

                      HTTP Status 400 - Required String parameter 'aa' is not present

                      可以通过required=false或者true来要求@RequestParam配置的前端参数是

                      否一定要传:

// required=false表示不传的话,会给参数赋值为null,required=true就是必须要有  
@RequestMapping("testRequestParam")    
    public String filesUpload(@RequestParam(value="aa", required=true) String inputStr, HttpServletRequest request)  

                      如果用@RequestMapping注解的参数是int基本类型,但是required=false,

                      这时如果不传参数值会报错,因为不传值,会赋值为null给int,这个不可以

@RequestMapping("testRequestParam")    
   public String filesUpload(@RequestParam(value="aa", required=true) String inputStr,   
        @RequestParam(value="inputInt", required=false) int inputInt  
        ,HttpServletRequest request) {    
      
    // ......省略  
    return "index";  
}  

                      错误信息:

                      “Consider declaring it as object wrapper for the corresponding primitive type.”

                      解决办法:用Integer替代int。

                      在看一个例子,用于了解参数自动类型转换,重点在该类的注释上面:

/**

* 如果请求参数中的 userId 是纯数字,那么使用 @RequestParam

* 时,可以根据自己的需求将方法参数类型设置为 Long、Integer、

* String,它将自动进行类型转换

*/

@RequestMapping(value="/user/show")

public ModelAndView show(@RequestParam(value="userId",defaultValue="1") Long userId) {

     // 创建 ModelAndView 对象,并设置视图名称

     ModelAndView mv = new ModelAndView("show");

    // 添加模型数据

    mv.addObject("msg", "User ID:" + userId);

    return mv;

}



              @ResponseBody

              @ResponseBody是作用在方法上的,@ResponseBody 表示该方法的返回结果直

              接写入 HTTP response body 中,一般在异步获取数据时使用【也就是AJAX】,

              在使用 @RequestMapping后,返回值通常解析为跳转路径,但是加上

              @ResponseBody 后返回结果不会被解析为跳转路径,而是直接写入

              HTTP response body 中。 比如异步获取 json 数据,加上 @ResponseBody 后,

              会直接返回 json 数据。@RequestBody 将 HTTP 请求正文插入方法中,使用适合

              的 HttpMessageConverter 将请求体写入某个对象。下面是Spring MVC返回JSON

              的例子:

                     例一,返回ModelAndView,其中包含map集

/*
     * 返回ModelAndView类型的结果
     * 检查用户名的合法性,如果用户已经存在,返回false,否则返回true(返回json数据,格式为{"valid",true})
     */
    @RequestMapping(value = "/checkNameExistsMethod2", produces = "application/json;charset=UTF-8") //这里的produces值在不设置的情况下将根据返回结果自动决定
    @ResponseBody
    public ModelAndView checkNameValidMethod2(@RequestParam String name) {
        boolean result = true;
       //...
        Map<String, Boolean> map = new HashMap<>();
        map.put("valid", result);
        return new ModelAndView(new MappingJackson2JsonView(), map);
    }

                     例二,返回String类型的json,这里有两种方式:

                                方式一:使用jackson-databind-x.x.x.jar包中的ObjectMapper将Map型

                                               数据改写为String并返回。

/*
     * 返回String类型的结果
     * 检查用户名的合法性,如果用户已经存在,返回false,否则返回true(返回json数据,格式为{"valid",true})
     */
    @RequestMapping(value = "/checkNameExistsMethod1", produces = "application/json;charset=UTF-8")
    @ResponseBody
    public String checkNameValidMethod1(@RequestParam String name) {
        boolean result = true;
        //...
        Map<String, Boolean> map = new HashMap<>();
        map.put("valid", result);
        ObjectMapper mapper = new ObjectMapper();
        String resultString = "";
        try {
            resultString = mapper.writeValueAsString(map);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return resultString;
    }

                          方式二,直接返回字符串,主要key/value值必须使用含有转义字符\的双引

                                        号,单引号无效。

/*
     * 返回String类型的结果
     * 检查用户名的合法性,如果用户已经存在,返回false,否则返回true(返回json数据,格式为{"valid",true})
     */
    @RequestMapping(value = "/checkNameExistsMethod1", produces = "application/json;charset=UTF-8")
    @ResponseBody
    public String checkNameValidMethod1(@RequestParam String name) {
        boolean result = true;
     
        String resultString = "{\"result\":true}"; //注意一定是双引号 "{\"result\":\"success\"}"
      
        return resultString;
    }

                     例三,返回任何预定义class类型的结果:

@RequestMapping(value = "/findEmployeebyName")
    @ResponseBody
    public Employee findEmployeebyName(String name) {
        List<Employee> lstEmployees = employeeService.getAllEmployees();
        for (Employee employee : lstEmployees) {
            if (employee.getName().equals(name))
                return employee;
        }
        return null;
    }

                     例四,使用HttpServletResponse对象的response.getWriter().write(xxx)方法

@RequestMapping(value="/hello5.do")
    public void hello(HttpServletResponse response) throws IOException{
        UserInfo u1=new UserInfo();
        u1.setAge(15);
        u1.setUname("你好");
        
        UserInfo u2=new UserInfo();
        u2.setAge(152);
        u2.setUname("你好2");
        Map<String,UserInfo> map=new HashMap<String, UserInfo>();
        map.put("001", u1);
        map.put("002", u2);
        String jsonString = JSON.toJSONString(map);
        response.setCharacterEncoding("utf-8");
        response.getWriter().write(jsonString);
        response.getWriter().close();
        
    }

     (4)@ModelAttribute

              @ModelAttribute使用场景如下:

              * 注释在无返回值方法上,方法上未使用@RequestMapping

              * 注释在有返回值方法上,方法上未使用@RequestMapping

              * 注释在方法上,并且方法上使用了@RequestMapping

              * 注释在方法的参数上

              @ModelAttribute注解作用在方法上或者方法的参数上,表示将被注解的方法的

              返回值或者是被注解的参数作为Model的属性加入到Model中,然后Spring框架

              自会将这个Model传递给ViewResolver。简单的说@ModelAttribute最主要的作

              用是将数据添加到模型对象中,用于视图页面展示时使用。@ModelAttribute等

              价于 model.addAttribute("attributeName", abc); 但是根据@ModelAttribute注释

              的位置不同,和其他注解组合使用,致使含义有所不同

            (a)@ModelAttribute注释在无返回值方法上,方法上未使用@RequestMapping

                     被@ModelAttribute注释的方法会在此controller每个方法执行前被执行

@Controller 
public class HelloWorldController { 
    @ModelAttribute 
    public void populateModel(@RequestParam String abc, Model model) { 
         model.addAttribute("attributeName", abc); 
      } 

    @RequestMapping(value = "/helloWorld") 
    public String helloWorld() { 
       return "helloWorld"; 
        } 
 }

                     上例中会先执行populateModel方法,然后在执行helloWorld方法执行,并

                     参数abc被带到Model中后接着带入helloWorld方法中,当返回视图

                     “helloWorld”后,Model会被带到页面上。

                     当把populateModel方法和helloWorld方法合二为一将如下例(这是我们常

                     用的方法):                  

@Controller 
public class HelloWorldController { 
    @RequestMapping(value = "/helloWorld") 
    public String helloWorld(@RequestParam String abc, Model model) { 
       model.addAttribute("attributeName", abc); 
       return "helloWorld"; 
        } 
 }

            (b)注释在有返回值方法上,方法上未使用@RequestMapping       

@ModelAttribute 
public Account addAccount(@RequestParam String number) { 
     Account account = accountManager.findAccount(number); 
     return account ;
} 

                     由于model属性的名称没有指定,它由返回类型隐含表示,如这个方法返

                     回Account类型,那么这个model属性的名称是account。这段相当于如下

                     代码:

 model.addAttribute("account", account); 

                     但是这样用很不爽,如果返回值是int,那么上段代码相当于:

                     model.addAttribute("int",value);这时可以使用@ModelAttribute(value=“”)

                     或@ModelAttribute(“”)

                     示例如下:

@ModelAttribute("attributeName") 
public Account addAccount(@RequestParam String number) { 
     Account account = accountManager.findAccount(number); 
     return account ;
} 

                     这时上段代码相当于:model.addAttribute("attributeName",account);

            (c)注释在方法上,并且方法参数上使用了@RequestMapping

                     用@ModelAttribute注解@RequestMapping方法的场景很少会用到,因

                     为这种场景下的返回值就不是视图了而是ModelAttribute的value值,如

                     果不是视图,那么@RequestMapping注解的方法也失去了本身的含义。

            (d)@ModelAttribute注释在方法的参数上

 public String test1(@ModelAttribute("user") UserModel user)

                    它的作用是将该绑定的命令对象以“user”为名称添加到模型对象中供视图页

                    面展示使用。我们此时可以在视图页面使用${user.username}来获取绑定的

                    命令对象的属性。

              关于@ModelAttribute想更细致的了解,可以参考文章:

              https://blog.csdn.net/catoop/article/details/51171108(该文章中可能有些错误)

              https://jingyan.baidu.com/article/a3aad71a158d4bb1fa00967b.html

     (5)@SessionAttribute

              @ModelAttribute注解作用在方法上或者方法的参数上,表示将被注解的方法的

              返回值或者是被注解的参数作为Model的属性加入到Model中,然后Spring框架

              自会将这个Model传递给ViewResolver。Model的生命周期只有一个http请求的

              处理过程,请求处理完后,Model就销毁了。如果想让参数在多个请求间共享,

              那么可以用到要说到的@SessionAttribute注解。

              注:SessionAttribute只能作用在类上。用法,看例子解说:

@Controller
@RequestMapping("sc")
@SessionAttributes("name")
public class SessionController {
    @RequestMapping("session")
    public String sessions(Model model,HttpSession session){
        model.addAttribute("name", "winclpt");
        session.setAttribute("myName", "chke");
        return "session";
}

              上面的代码将Model中的name参数保存到了session中(如果Model中没有

              name参数,而session中存在一个name参数,那么SessionAttribute会讲这个

              参数塞进Model中)

              原理理解:它的做法大概可以理解为将Model中的被注解的attrName属性保存

                                在一个SessionAttributesHandler中,在每个RequestMapping的方

                                法执行后,这个SessionAttributesHandler都会将它自己管理的“属性”

                                从Model中写入到真正的HttpSession;同样,在每个

                                RequestMapping的方法执行前,SessionAttributesHandler会将

                                HttpSession中的被@SessionAttributes注解的属性写入到新的

                                Model中。

              如果想删除session中共享的参数,可以通过SessionStatus.setComplete(),

              这句只会删除通过@SessionAttribute保存到session中的参数。

              SessionAttribute有两个参数:

                String[] value:要保存到session中的参数名称

                Class[] typtes:要保存的参数的类型,和value中顺序要对应上

              可以这样写:@SessionAttributes(types = {User.class,Dept.class},value={“attr1”,”attr2”})

     (6)@AutoWired和@Service

              因该注意使用@Service时需要一个<component-scan/>来扫描依赖基本包

              <context:component-scan base-package="com.Service...."/>

              其它略,这两个标签太熟悉了。

     (7)@DateTimeFormat和@JsonFormat(非Spring标签)

            (a)@DateTimeFormat

                     通过例子来讲解:

                   (i)定义一个pojo,它有一个 java.util.Date 类型的属性 date。         


import java.util.Date;
 
public class DateVo {
    private Date date;
 
    public void setDate(Date date){
        this.date = date;
    }
    public Date getDate(){
        return date;
    }
}

                   (ii)定义一个Controller

@RestController
@RequestMapping("/date/")
public class DateController {
 
    @RequestMapping("test")
    public DateVo getDate(DateVo vo){
        System.out.println("date1:"+vo.getDate());
 
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date = sdf.format(vo.getDate());
        System.out.println("date2:"+date);
 
        DateVo vo2 = new DateVo();
        vo2.setDate(new Date());
        return vo2;
    }
}

                   (iii)访问 /date/test ,并传入参数:2018-08-02 22:05:55。发现不能访

                             问,报异常,错误信息如下:

                             这时,就可以使用 Spring 的 @DateTimeFormat注解格式化参数,

                             来解决上述问题。

                   (iv)改造 DateVo:

public class DateVo {
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date date;
 
    public void setDate(Date date){
        this.date = date;
    }
    public Date getDate(){
        return date;
    }
}

                             再像上面一样访问 /date/test ,并传入参数:2018-08-02 22:05:55,

                             将在控制台上打印:

                             date1:Thu Aug 02 22:05:55 CST 2018

                             date2:2018-08-02 22:05:55

                             可以看到,加入 @DateTimeFormat 注解后参数可以被接收到了,

                             但日期时间的格式还是需要自己再手动转换一下。这是因为

                             @DateTimeFormat 注解的 pattern 属性值指定的日期时间格式并

                             不是将要转换成的日期格式,这个指定的格式是和传入参数的日

                             期格式,假如注解为:

                             @DateTimeFormat(pattern="yyyy/MM/dd HH:mm:ss")

                             则传入的参数应该是这样的:

                             2018/08/02 22:05:55

                             否则会抛出异常。

                             注:可对java.util.Date、java.util.Calendar、java.long.Long

                                    时间类型进行标注。

            (b)出参格式化

                     在上述示例中,调用接口的返回结果为:

                     "date": "2018-08-01T14:25:31.296+0000"

                     这个格式并不是我们想要的,那么如何将其进行格式化?这时就需要

                     用到 jackson 的 @JsonFormat 注解。

                   (i)改造 DateVo:

public class DateVo {
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    @JsonFormat(
            pattern = "yyyy-MM-dd HH:mm:ss"
    )
    private Date date;
 
    public void setDate(Date date){
        this.date = date;
    }
    public Date getDate(){
        return date;
    }
}

                             继续访问 /date/test ,并传入参数:2018-08-02 22:05:55,可以

                             看到接口返回的结果为:

                             "date": "2018-08-01 14:32:57"

                             虽然时间格式正确了,但实际上当前时间是

                             “2018-08-01 22:32:57” ,早了8个小时。因为,jackson在序列化

                             时间时是按照国际标准时间GMT进行格式化的,而在国内默认时

                             区使用的是CST时区,两者相差8小时。

                             所以,@JsonFormat 注解还要再加一个属性:

@JsonFormat(
    pattern = "yyyy-MM-dd HH:mm:ss",
    timezone = "GMT+8"
)
private Date date;

                   (ii)关于JsonFormat的说明

                            因为 @JsonFormat 注解不是 Spring 自带的注解,所以使用该注

                            解前需要添加 jackson 相关的依赖包。当然,如果是 SpringBoot

                            项目就不需要自己手动添加依赖了,因为在 spring-boot-start-web

                            下已经包含了 jackson 相关依赖。

                             

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值